Wie konvertiere ich UTF-8 Byte [] in String?

Ich habe ein byte[]Array, das aus einer mir bekannten Datei geladen wird und UTF-8 enthält .

In einigen Debugging-Codes muss ich es in eine Zeichenfolge konvertieren. Gibt es einen Einzeiler, der dies erledigt?

Unter dem Deckmantel sollte es nur eine Zuordnung und eine Memkopie sein , also sollte es möglich sein , auch wenn es nicht implementiert ist.

string result = System.Text.Encoding.UTF8.GetString(byteArray);

Es gibt mindestens vier verschiedene Möglichkeiten, diese Konvertierung durchzuführen.

1. GetString von Encoding
   , aber Sie können die ursprünglichen Bytes nicht zurückerhalten, wenn diese Bytes Nicht-ASCII-Zeichen enthalten.

2. BitConverter.ToString
   Die Ausgabe ist eine durch "-" getrennte Zeichenfolge, es gibt jedoch keine in .NET integrierte Methode, um die Zeichenfolge zurück in ein Byte-Array zu konvertieren.

3. Convert.ToBase64String Mit können
   Sie die Ausgabezeichenfolge einfach wieder in ein Byte-Array konvertieren Convert.FromBase64String.
   Hinweis: Die Ausgabezeichenfolge kann '+', '/' und '=' enthalten. Wenn Sie die Zeichenfolge in einer URL verwenden möchten, müssen Sie sie explizit codieren.

4. HttpServerUtility.UrlTokenEncode Mit können
   Sie die Ausgabezeichenfolge einfach wieder in ein Byte-Array konvertieren HttpServerUtility.UrlTokenDecode. Die Ausgabezeichenfolge ist bereits URL-freundlich! Der Nachteil ist, dass eine System.WebMontage erforderlich ist, wenn Ihr Projekt kein Webprojekt ist.

Ein vollständiges Beispiel:

byte[] bytes = { 130, 200, 234, 23 }; // A byte array contains non-ASCII (or non-readable) characters

string s1 = Encoding.UTF8.GetString(bytes); // ���
byte[] decBytes1 = Encoding.UTF8.GetBytes(s1);  // decBytes1.Length == 10 !!
// decBytes1 not same as bytes
// Using UTF-8 or other Encoding object will get similar results

string s2 = BitConverter.ToString(bytes);   // 82-C8-EA-17
String[] tempAry = s2.Split('-');
byte[] decBytes2 = new byte[tempAry.Length];
for (int i = 0; i < tempAry.Length; i++)
    decBytes2[i] = Convert.ToByte(tempAry[i], 16);
// decBytes2 same as bytes

string s3 = Convert.ToBase64String(bytes);  // gsjqFw==
byte[] decByte3 = Convert.FromBase64String(s3);
// decByte3 same as bytes

string s4 = HttpServerUtility.UrlTokenEncode(bytes);    // gsjqFw2
byte[] decBytes4 = HttpServerUtility.UrlTokenDecode(s4);
// decBytes4 same as bytes

Eine allgemeine Lösung zum Konvertieren von Bytearray in Zeichenfolge, wenn Sie die Codierung nicht kennen:

static string BytesToStringConverted(byte[] bytes)
{
    using (var stream = new MemoryStream(bytes))
    {
        using (var streamReader = new StreamReader(stream))
        {
            return streamReader.ReadToEnd();
        }
    }
}

Definition:

public static string ConvertByteToString(this byte[] source)
{
    return source != null ? System.Text.Encoding.UTF8.GetString(source) : null;
}

Verwenden von:

string result = input.ConvertByteToString();

Das Konvertieren von a byte[]in a stringscheint einfach zu sein, aber jede Art von Codierung kann die Ausgabezeichenfolge durcheinander bringen. Diese kleine Funktion funktioniert nur ohne unerwartete Ergebnisse:

private string ToString(byte[] bytes)
{
    string response = string.Empty;

    foreach (byte b in bytes)
        response += (Char)b;

    return response;
}

Verwenden von (byte)b.ToString("x2")Ausgängenb4b5dfe475e58b67

public static class Ext {

    public static string ToHexString(this byte[] hex)
    {
        if (hex == null) return null;
        if (hex.Length == 0) return string.Empty;

        var s = new StringBuilder();
        foreach (byte b in hex) {
            s.Append(b.ToString("x2"));
        }
        return s.ToString();
    }

    public static byte[] ToHexBytes(this string hex)
    {
        if (hex == null) return null;
        if (hex.Length == 0) return new byte[0];

        int l = hex.Length / 2;
        var b = new byte[l];
        for (int i = 0; i < l; ++i) {
            b[i] = Convert.ToByte(hex.Substring(i * 2, 2), 16);
        }
        return b;
    }

    public static bool EqualsTo(this byte[] bytes, byte[] bytesToCompare)
    {
        if (bytes == null && bytesToCompare == null) return true; // ?
        if (bytes == null || bytesToCompare == null) return false;
        if (object.ReferenceEquals(bytes, bytesToCompare)) return true;

        if (bytes.Length != bytesToCompare.Length) return false;

        for (int i = 0; i < bytes.Length; ++i) {
            if (bytes[i] != bytesToCompare[i]) return false;
        }
        return true;
    }

}

Es gibt auch die Klasse UnicodeEncoding, die recht einfach zu verwenden ist:

ByteConverter = new UnicodeEncoding();
string stringDataForEncoding = "My Secret Data!";
byte[] dataEncoded = ByteConverter.GetBytes(stringDataForEncoding);

Console.WriteLine("Data after decoding: {0}", ByteConverter.GetString(dataEncoded));

Alternative:

 var byteStr = Convert.ToBase64String(bytes);

Ein Linq-Einzeiler zum Konvertieren eines byteArrFilenameaus einer Datei gelesenen Byte-Arrays in eine reine ASCII-Zeichenfolge mit nullter Endung wäre: Praktisch zum Lesen von Dingen wie Dateiindex-Tabellen in alten Archivformaten.

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

Ich verwende hier '?'als Standardzeichen alles, was nicht rein ASCII ist, aber das kann natürlich geändert werden. Wenn Sie sicher sein möchten, dass Sie es erkennen können, verwenden Sie '\0'stattdessen einfach , da das TakeWhileam Anfang sicherstellt, dass eine auf diese Weise erstellte Zeichenfolge möglicherweise keine '\0'Werte aus der Eingabequelle enthalten kann .

BitConverterKlasse kann verwendet werden, um ein byte[]in zu konvertieren string.

var convertedString = BitConverter.ToString(byteAttay);

Die Dokumentation der BitConverterKlasse kann auf MSDN erfolgen

Meines Wissens garantiert keine der angegebenen Antworten ein korrektes Verhalten bei Nullbeendigung. Bis mich jemand anders zeigt, habe ich meine eigene statische Klasse geschrieben, um dies mit den folgenden Methoden zu behandeln:

// 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 das startIndexwar in dem Beispiel, an dem ich speziell arbeitete, dass ich a byte[]als Array von nullterminierten Zeichenfolgen analysieren musste . Es kann im einfachen Fall sicher ignoriert werden

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

        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);
        }

Wenn Sie .NET35 oder .NET35 CE verwenden, müssen Sie zusätzlich zur ausgewählten Antwort den Index des ersten zu decodierenden Bytes und die Anzahl der zu decodierenden Bytes angeben:

string result = System.Text.Encoding.UTF8.GetString(byteArray,0,byteArray.Length);

Probieren Sie diese Konsolen-App aus:

static void Main(string[] args)
{
    //Encoding _UTF8 = Encoding.UTF8;
    string[] _mainString = { "Héllo 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);
}

Ich habe in diesem Beitrag einige Antworten gesehen und es ist möglich, als abgeschlossenes Basiswissen zu gelten, da es in der C # -Programmierung verschiedene Ansätze gibt, um dasselbe Problem zu lösen. Es muss nur ein Unterschied zwischen Pure UTF-8 und UTF-8 mit Stückliste berücksichtigt werden .

In der letzten Woche muss ich bei meiner Arbeit eine Funktionalität entwickeln, die CSV-Dateien mit Stückliste und andere CSVs mit reinem UTF-8 (ohne Stückliste) ausgibt. Jeder CSV-Dateikodierungstyp wird von verschiedenen nicht standardisierten APIs verwendet, nämlich dieser API liest UTF-8 mit Stückliste und die andere API liest ohne Stückliste. Ich muss die Referenzen zu diesem Konzept recherchieren und lesen " Was ist der Unterschied zwischen UTF-8 und UTF-8 ohne Stückliste? ". Diskussion über Stapelüberlauf und diesen Wikipedia-Link " Byte Order Mark ", um meinen Ansatz zu erstellen.

Schließlich musste meine C # -Programmierung für die beiden UTF-8-Codierungstypen (mit Stückliste und rein) ähnlich sein wie in diesem Beispiel unten:

//for UTF-8 with B.O.M., equals shared by Zanoni (at top)
string result = System.Text.Encoding.UTF8.GetString(byteArray);

//for Pure UTF-8 (without B.O.M.)
string result = (new UTF8Encoding(false)).GetString(byteArray);