Wie konvertiert man UTF-8 byte[] in string

Question

J'ai un byte[] Array, das aus einer Datei geladen wird, von der ich zufällig weiß, dass sie UTF-8 .

In einigen Debugging-Codes muss ich sie in eine Zeichenkette umwandeln. Gibt es einen Einzeiler, der dies tut?

Unter der Haube sollte es nur eine Zuweisung und eine memcopy Auch wenn es nicht umgesetzt wird, sollte es also möglich sein.

Answer 1

Alternativ dazu:

 var byteStr = Convert.ToBase64String(bytes);

Answer 2

Ein LINQ-Einzeiler zum Konvertieren eines Byte-Arrays byteArrFilename aus einer Datei in eine reine ASCII-Zeichenkette im C-Stil mit Nullterminierung umzuwandeln, wäre dies: Praktisch zum Lesen von Dingen wie Datei-Index-Tabellen in alten Archivformaten.

String filename = new String(byteArrFilename.TakeWhile(x => x != 0)
                              .Select(x => x < 128 ? (Char)x : '?').ToArray());

Ich benutze '?' als Standardzeichen für alles, was nicht reines ASCII ist, aber das kann natürlich geändert werden. Wenn Sie sicher sein wollen, dass Sie es erkennen können, verwenden Sie einfach '\0' stattdessen, da die TakeWhile am Anfang stellt sicher, dass eine auf diese Weise aufgebaute Zeichenkette unmöglich enthalten kann '\0' Werte aus der Eingangsquelle.

Answer 3

Meines Wissens garantiert keine der gegebenen Antworten ein korrektes Verhalten bei Nullterminierung. Bis mich jemand eines Besseren belehrt, habe ich meine eigene statische Klasse für die Behandlung dieses Problems mit den folgenden Methoden geschrieben:

// Mimics the functionality of strlen() in c/c++
// Needed because niether StringBuilder or Encoding.*.GetString() handle \0 well
static int StringLength(byte[] buffer, int startIndex = 0)
{
    int strlen = 0;
    while
    (
        (startIndex + strlen + 1) < buffer.Length // Make sure incrementing won't break any bounds
        && buffer[startIndex + strlen] != 0       // The typical null terimation check
    )
    {
        ++strlen;
    }
    return strlen;
}

// This is messy, but I haven't found a built-in way in c# that guarentees null termination
public static string ParseBytes(byte[] buffer, out int strlen, int startIndex = 0)
{
    strlen = StringLength(buffer, startIndex);
    byte[] c_str = new byte[strlen];
    Array.Copy(buffer, startIndex, c_str, 0, strlen);
    return Encoding.UTF8.GetString(c_str);
}

Der Grund für die startIndex war, dass ich in dem Beispiel, an dem ich gerade arbeitete, eine byte[] als ein Array von Zeichenfolgen mit Null-Ende. Sie kann im einfachen Fall sicher ignoriert werden

Answer 4

Probieren Sie diese Konsolenanwendung aus:

static void Main(string[] args)
{
    //Encoding _UTF8 = Encoding.UTF8;
    string[] _mainString = { "Hello, World!" };
    Console.WriteLine("Main String: " + _mainString);

    // Convert a string to UTF-8 bytes.
    byte[] _utf8Bytes = Encoding.UTF8.GetBytes(_mainString[0]);

    // Convert UTF-8 bytes to a string.
    string _stringuUnicode = Encoding.UTF8.GetString(_utf8Bytes);
    Console.WriteLine("String Unicode: " + _stringuUnicode);
}

Answer 5

Hier ist ein Ergebnis, bei dem Sie sich nicht um die Kodierung kümmern mussten. Ich habe es in meiner Netzwerkklasse verwendet und schicke damit binäre Objekte als String.

public static byte[] String2ByteArray(string str)
{
    char[] chars = str.ToArray();
    byte[] bytes = new byte[chars.Length * 2];

    for (int i = 0; i < chars.Length; i++)
        Array.Copy(BitConverter.GetBytes(chars[i]), 0, bytes, i * 2, 2);

    return bytes;
}

public static string ByteArray2String(byte[] bytes)
{
    char[] chars = new char[bytes.Length / 2];

    for (int i = 0; i < chars.Length; i++)
        chars[i] = BitConverter.ToChar(bytes, i * 2);

    return new string(chars);
}