Como converter UTF-8 byte para string?

Eu tenho uma matriz byte[] que é carregada de um arquivo que eu sei que contém UTF-8 . Em algum código de debugging, preciso convertê-lo em uma string. Existe um forro que fará isso?

Nos bastidores , deve ser apenas uma alocação e uma cópia , por isso, mesmo que não seja implementada, deve ser possível.

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

Existem pelo menos quatro maneiras diferentes de fazer essa conversão.

  1. GetString da codificação
    , mas você não poderá recuperar os bytes originais se esses bytes tiverem caracteres não-ASCII.

  2. BitConverter.ToString
    A saída é uma string delimitada por “-“, mas não há nenhum método interno do .NET para converter a string de volta em array de bytes.

  3. Convert.ToBase64String
    Você pode facilmente converter a seqüência de saída de volta para a matriz de bytes usando Convert.FromBase64String .
    Nota: A cadeia de saída pode conter ‘+’, ‘/’ e ‘=’. Se você quiser usar a string em um URL, precisará codificá-lo explicitamente.

  4. HttpServerUtility.UrlTokenEncode
    Você pode facilmente converter a seqüência de saída de volta para a matriz de bytes usando HttpServerUtility.UrlTokenDecode . A string de saída já é compatível com URL! A desvantagem é que precisa de uma assembly System.Web se seu projeto não for um projeto da web.

Um exemplo completo:

 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 

Uma solução geral para converter de array de bytes em string quando você não conhece a codificação:

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

Definição:

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

Usando:

 string result = input.ConvertByteToString(); 

Converter um byte[] em uma string parece simples, mas qualquer tipo de codificação pode atrapalhar a string de saída. Esta pequena function apenas funciona sem resultados inesperados:

 private string ToString(byte[] bytes) { string response = string.Empty; foreach (byte b in bytes) response += (Char)b; return response; } 

Usando (byte)b.ToString("x2") , saídas 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; } } 

Há também a class UnicodeEncoding, bastante simples em uso:

 ByteConverter = new UnicodeEncoding(); string stringDataForEncoding = "My Secret Data!"; byte[] dataEncoded = ByteConverter.GetBytes(stringDataForEncoding); Console.WriteLine("Data after decoding: {0}", ByteConverter.GetString(dataEncoded)); 

Alternativamente:

  var byteStr = Convert.ToBase64String(bytes); 

Um one-liner Linq para converter um array byte byteArrFilename lido a partir de um arquivo para uma string ascii C-style zero-terminada pura seria este: Handy para ler coisas como tabelas de índice de arquivo em formatos antigos de arquivo.

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

Eu uso '?' como char padrão para qualquer coisa não pura ascii aqui, mas isso pode ser alterado, é claro. Se você quiser ter certeza de que é possível detectá-lo, use '\0' , pois o TakeWhile no início garante que uma string construída dessa maneira não possa conter valores '\0' da origem de input.

BitConverter class BitConverter pode ser usada para converter um byte[] em string .

 var convertedString = BitConverter.ToString(byteAttay); 

Documentação da class BitConverter pode ser fonte no MSDN

Que eu saiba, nenhuma das respostas dadas garante um comportamento correto com terminação nula. Até que alguém me mostre de maneira diferente, escrevi minha própria class estática para lidar com isso com os seguintes methods:

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

A razão para o startIndex era no exemplo em que eu estava trabalhando especificamente eu precisava analisar um byte[] como uma matriz de seqüências de caracteres terminadas por nulo. Pode ser ignorado com segurança no caso simples

Tente isto:

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

hier é um resultado onde você não precisa se preocupar com a codificação. Eu usei na minha class de rede e enviei objects binários como string com ela.

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