utf8 - stringbuilder utf 8 c#




¿Cómo convertir UTF-8 byte[] a cadena? (9)

Tengo una matriz de byte[] que se carga desde un archivo que, por casualidad, contiene UTF-8 . En algún código de depuración, necesito convertirlo en una cadena. ¿Hay un forro que hará esto?

Debajo de las coberturas, debe ser solo una asignación y una copia , por lo que incluso si no se implementa, debería ser posible.


Alternativamente:

 var byteStr = Convert.ToBase64String(bytes);

Hay al menos cuatro formas diferentes de hacer esta conversión.

  1. Codificación GetString
    , pero no podrá recuperar los bytes originales si esos bytes tienen caracteres no ASCII.

  2. BitConverter.ToString
    La salida es una cadena delimitada "-", pero no hay un método incorporado de .NET para convertir la cadena de nuevo a una matriz de bytes.

  3. Convert.ToBase64String
    Puede convertir fácilmente la cadena de salida de nuevo a matriz de bytes utilizando Convert.FromBase64String .
    Nota: la cadena de salida podría contener '+', '/' y '='. Si desea utilizar la cadena en una URL, debe codificarla explícitamente.

  4. HttpServerUtility.UrlTokenEncode
    Puede convertir fácilmente la cadena de salida de nuevo a la matriz de bytes utilizando HttpServerUtility.UrlTokenDecode . La cadena de salida ya es compatible con URL! El inconveniente es que necesita System.Web Assembly si su proyecto no es un proyecto web.

Un ejemplo 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

Prueba esto:

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

Que yo sepa, ninguna de las respuestas dadas garantiza un comportamiento correcto con terminación nula. Hasta que alguien me muestra lo contrario, escribí mi propia clase estática para manejar esto con los siguientes métodos:

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

La razón para el startIndex estaba en el ejemplo en el que estaba trabajando específicamente, necesitaba analizar un byte[] como una matriz de cadenas terminadas en nulo. Se puede ignorar con seguridad en el caso simple


Un linq de una sola línea para convertir una matriz de bytes byteArrFilename de un archivo a una cadena terminada en cero de estilo C puro ascii sería esta: Práctica para leer cosas como tablas de índice de archivos en formatos de archivo antiguos.

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

Yo uso '?' como char por defecto para cualquier cosa que no sea puro ascii aquí, pero eso se puede cambiar, por supuesto. Si desea estar seguro de que puede detectarlo, simplemente use '\0' lugar, ya que el TakeWhile al principio garantiza que una cadena construida de esta manera no pueda contener valores '\0' de la fuente de entrada.


Una solución general para convertir de una matriz de bytes a una cadena cuando no conoce la codificación:

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

hier es un resultado en el que no tenías que preocuparte por la codificación. Lo usé en mi clase de red y envié objetos binarios como una cadena con él.

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

BitConverter clase BitConverter se puede usar para convertir un byte[] a string .

var convertedString = BitConverter.ToString(byteAttay);

La documentación de la clase BitConverter puede ser fount en MSDN


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




type-conversion