Wie UTF-8-Byte [], um Zeichenfolge zu konvertieren?

https://stackoverflow.com/questions/1003275

05-07-2019
|

Frage

ich eine byte[] Array haben, die aus einer Datei geladen wird, die ich bekannt vorkommen, enthält UTF-8 . In einigen Debugging-Code, muss ich es in eine Zeichenfolge konvertieren. Gibt es einen Einzeiler, die dies tun werden?

Unter den Abdeckungen sollte es nur eine Zuordnung und ein memcopy , also auch wenn es nicht umgesetzt wird, soll es möglich sein.

Lösung

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

Andere Tipps

Es sind mindestens vier verschiedene Möglichkeiten, um diese Umwandlung zu tun.

Encoding des GetString in, aber Sie werden das ursprüngliche Bytes erhalten werden können, nicht zurück, wenn dieses Bytes nicht-ASCII-Zeichen hat.
BitConverter.ToString
Der Ausgang ist eine "-". Getrennte Zeichenfolge, aber es gibt keine .NET integrierte Methode die Zeichenfolge zurück in Byte-Array zu konvertieren
Convert.ToBase64String
Sie leicht mit Convert.FromBase64String die Ausgabezeichenfolge zurück zu Byte-Array umwandeln kann
. Hinweis: Der Ausgabestring enthalten könnte '+', ‚/ 'und '='. Wenn Sie die Zeichenfolge in einer URL verwenden möchten, müssen Sie dies explizit kodieren.
HttpServerUtility.UrlTokenEncode
Sie bequem die Ausgabezeichenfolge zurück zu Byte-Array unter Verwendung HttpServerUtility.UrlTokenDecode umwandeln kann. Der Ausgabestring wird URL bereits freundlich! Der Nachteil ist, es braucht System.Web Montag, wenn Ihr Projekt nicht ein Web-Projekt 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 zur Umwandlung von Byte-Array in einem String, 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;
}

Verwendung:

string result = input.ConvertByteToString();

ein byte[] zu einem string Converting scheint einfach, aber jede Art von Codierung ist wahrscheinlich die Ausgabezeichenfolge zu vermasseln. 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;
}

Mit (byte)b.ToString("x2"), Ausgänge b4b5dfe475e58b67

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 Klasse Unicodeen, ganz einfach in der Anwendung:

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

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

Alternativ:

 var byteStr = Convert.ToBase64String(bytes);

Ein Linq Einzeiler für eine Byte-Array Umwandlung byteArrFilename aus einer Datei zu einem reinen ascii C-Stil Null-terminierten String zu lesen wäre dies:. Praktisch für Dinge wie Dateiindextabellen in alten Archivformaten zu lesen

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

Ich verwende '?' als Standard char für nichts rein ascii hier, aber das kann geändert werden, natürlich. Wenn Sie sicher sein wollen, können Sie es erkennen, nur '\0' stattdessen verwenden, da die TakeWhile zu Beginn stellen sicher, dass eine Zeichenfolge auf diese Weise gebaut unmöglich '\0' Werte von der Eingangsquelle enthält.

BitConverter Klasse kann verwendet werden, um eine byte[] zu konvertieren string.

var convertedString = BitConverter.ToString(byteAttay);

Dokumentation von BitConverter Klasse kann fount auf

Mein Wissen keine der gegebenen Antworten garantieren korrektes Verhalten mit Null-Terminierung. Bis jemand zeigt mir anders schrieb ich meine eigene statische Klasse für den Umgang mit dieser mit den folgenden Methoden:

// 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 den startIndex im Beispiel war ich arbeite speziell Ich brauchte eine byte[] als ein Array von null Strings beendet zu analysieren. Es kann sicher im einfachen Fall ignoriert werden

hier ist ein Ergebnis, wo man knapp mit Codierung zu stören hat. Ich habe es in meiner Netzwerk-Klasse und damit binäre Objekte als String senden.

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

Neben der gewählten Antwort, wenn Sie mit .NET35 oder .NET35 CE, müssen Sie den Index des ersten Bytes angeben, zu dekodieren, und die Anzahl von Bytes zu entschlüsseln:

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

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow