Преобразование в .net: Native Utf-8 ↔ Управляемая строка
Я создал эти два метода для преобразования Native utf-8 строк (char *) в управляемую строку и наоборот. Следующий код выполняет задание:
public IntPtr NativeUtf8FromString(string managedString)
{
byte[] buffer = Encoding.UTF8.GetBytes(managedString); // not null terminated
Array.Resize(ref buffer, buffer.Length + 1);
buffer[buffer.Length - 1] = 0; // terminating 0
IntPtr nativeUtf8 = Marshal.AllocHGlobal(buffer.Length);
Marshal.Copy(buffer, 0, nativeUtf8, buffer.Length);
return nativeUtf8;
}
string StringFromNativeUtf8(IntPtr nativeUtf8)
{
int size = 0;
byte[] buffer = {};
do
{
++size;
Array.Resize(ref buffer, size);
Marshal.Copy(nativeUtf8, buffer, 0, size);
} while (buffer[size - 1] != 0); // till 0 termination found
if (1 == size)
{
return ""; // empty string
}
Array.Resize(ref buffer, size - 1); // remove terminating 0
return Encoding.UTF8.GetString(buffer);
}
Пока NativeUtf8FromString в порядке, StringFromNativeUtf8 - беспорядок, но единственный безопасный код, который я мог бы запустить. Используя небезопасный код, я мог бы использовать байт *, но я не хочу небезопасного кода. Есть ли другой способ, которым кто-то может подумать о том, где мне не нужно копировать строку для каждого содержащегося байта, чтобы найти завершение 0.
Я просто добавляю здесь небезопасный код:
public unsafe string StringFromNativeUtf8(IntPtr nativeUtf8)
{
byte* bytes = (byte*)nativeUtf8.ToPointer();
int size = 0;
while (bytes[size] != 0)
{
++size;
}
byte[] buffer = new byte[size];
Marshal.Copy((IntPtr)nativeUtf8, buffer, 0, size);
return Encoding.UTF8.GetString(buffer);
}
Как вы видите, его не уродливые просто небезопасны.
Ответы
Ответ 1
Просто выполните ту же операцию, что и операция strlen(). Подумайте о том, чтобы поддерживать буфер вокруг, код действительно ускоряет сбор мусора.
public static IntPtr NativeUtf8FromString(string managedString) {
int len = Encoding.UTF8.GetByteCount(managedString);
byte[] buffer = new byte[len + 1];
Encoding.UTF8.GetBytes(managedString, 0, managedString.Length, buffer, 0);
IntPtr nativeUtf8 = Marshal.AllocHGlobal(buffer.Length);
Marshal.Copy(buffer, 0, nativeUtf8, buffer.Length);
return nativeUtf8;
}
public static string StringFromNativeUtf8(IntPtr nativeUtf8) {
int len = 0;
while (Marshal.ReadByte(nativeUtf8, len) != 0) ++len;
byte[] buffer = new byte[len];
Marshal.Copy(nativeUtf8, buffer, 0, buffer.Length);
return Encoding.UTF8.GetString(buffer);
}
Ответ 2
Немного быстрее, чем решение Ханса (на 1 меньше буфера):
private unsafe IntPtr AllocConvertManagedStringToNativeUtf8(string input) {
fixed (char* pInput = input) {
var len = Encoding.UTF8.GetByteCount(pInput, input.Length);
var pResult = (byte*)Marshal.AllocHGlobal(len + 1).ToPointer();
var bytesWritten = Encoding.UTF8.GetBytes(pInput, input.Length, pResult, len);
Trace.Assert(len == bytesWritten);
pResult[len] = 0;
return (IntPtr)pResult;
}
}
private unsafe string MarshalNativeUtf8ToManagedString(IntPtr pStringUtf8)
=> MarshalNativeUtf8ToManagedString((byte*)pStringUtf8);
private unsafe string MarshalNativeUtf8ToManagedString(byte* pStringUtf8) {
var len = 0;
while (pStringUtf8[len] != 0) len++;
return Encoding.UTF8.GetString(pStringUtf8, len);
}
Здесь я продемонстрировал последовательность действий:
var input = "Hello, World!";
var native = AllocConvertManagedStringToNativeUtf8(input);
var copy = MarshalNativeUtf8ToManagedString(native);
Marshal.FreeHGlobal(native); // don't leak unmanaged memory!
Trace.Assert(input == copy); // prove they're equal!