string awk - Convertir la cadena a la matriz de bytes en C#




examples unix (9)

Soy bastante nuevo en C #. Estoy convirtiendo algo de VB en C #. Tener un problema con la sintaxis de esta declaración:

if ((searchResult.Properties["user"].Count > 0))
{
    profile.User = System.Text.Encoding.UTF8.GetString(searchResult.Properties["user"][0]);
}

Entonces veo los siguientes errores:

Argumento 1: no se puede convertir de 'objeto' a 'byte []'

La mejor coincidencia de método sobrecargada para 'System.Text.Encoding.GetString (byte [])' tiene algunos argumentos no válidos

Traté de corregir el código basado en this publicación, pero aún no tengo éxito

string User = Encoding.UTF8.GetString("user", 0);

¿Alguna sugerencia?


Answers

static byte[] GetBytes(string str)
{
     byte[] bytes = new byte[str.Length * sizeof(char)];
     System.Buffer.BlockCopy(str.ToCharArray(), 0, bytes, 0, bytes.Length);
     return bytes;
}

static string GetString(byte[] bytes)
{
     char[] chars = new char[bytes.Length / sizeof(char)];
     System.Buffer.BlockCopy(bytes, 0, chars, 0, bytes.Length);
     return new string(chars);
}

Si ya tiene una matriz de bytes, necesitará saber qué tipo de codificación se utilizó para convertirla en esa matriz de bytes.

Por ejemplo, si la matriz de bytes fue creada así:

byte[] bytes = Encoding.ASCII.GetBytes(someString);

Deberás volver a convertirlo en una cadena como esta:

string someString = Encoding.ASCII.GetString(bytes);

Si puede encontrar en el código que heredó, la codificación utilizada para crear la matriz de bytes debería estar configurada.


utilizar esta

byte[] myByte= System.Text.ASCIIEncoding.Default.GetBytes(myString);

El siguiente enfoque funcionará solo si los caracteres son 1 byte. (Unicode predeterminado no funcionará ya que es de 2 bytes)

public static byte[] ToByteArray(string value)
{            
    char[] charArr = value.ToCharArray();
    byte[] bytes = new byte[charArr.Length];
    for (int i = 0; i < charArr.Length; i++)
    {
        byte current = Convert.ToByte(charArr[i]);
        bytes[i] = current;
    }

    return bytes;
}

Manteniéndolo simple


También puede usar un Método de extensión para agregar un método al tipo de string como se muestra a continuación:

static class Helper
{
   public static byte[] ToByteArray(this string str)
   {
      return System.Text.Encoding.ASCII.GetBytes(str);
   }
}

Y utilízalo como a continuación:

string foo = "bla bla";
byte[] result = foo.ToByteArray();

Un refinamiento de la edición de JustinStolle (uso de BlockCopy por parte de Eran Yogev).

La solución propuesta es de hecho más rápida que el uso de la codificación. El problema es que no funciona para codificar matrices de bytes de longitud desigual. Como se indica, genera una excepción fuera de límite. Aumentar la longitud en 1 deja un byte final cuando se decodifica desde una cadena.

Para mí, la necesidad vino cuando quería codificar desde DataTable a JSON . Estaba buscando una forma de codificar campos binarios en cadenas y decodificar de cadena a byte[] .

Por lo tanto, creé dos clases: una que envuelve la solución anterior (cuando se codifica desde cadenas está bien, porque las longitudes son siempre iguales), y otra que maneja la codificación byte[] .

Resolví el problema de longitud desigual agregando un solo carácter que me dice si la longitud original de la matriz binaria era impar ('1') o incluso ('0')

Como sigue:

public static class StringEncoder
{
    static byte[] EncodeToBytes(string str)
    {
        byte[] bytes = new byte[str.Length * sizeof(char)];
        System.Buffer.BlockCopy(str.ToCharArray(), 0, bytes, 0, bytes.Length);
        return bytes;
    }
    static string DecodeToString(byte[] bytes)
    {
        char[] chars = new char[bytes.Length / sizeof(char)];
        System.Buffer.BlockCopy(bytes, 0, chars, 0, bytes.Length);
        return new string(chars);
    }
}

public static class BytesEncoder
{
    public static string EncodeToString(byte[] bytes)
    {
        bool even = (bytes.Length % 2 == 0);
        char[] chars = new char[1 + bytes.Length / sizeof(char) + (even ? 0 : 1)];
        chars[0] = (even ? '0' : '1');
        System.Buffer.BlockCopy(bytes, 0, chars, 2, bytes.Length);

        return new string(chars);
    }
    public static byte[] DecodeToBytes(string str)
    {
        bool even = str[0] == '0';
        byte[] bytes = new byte[(str.Length - 1) * sizeof(char) + (even ? 0 : -1)];
        char[] chars = str.ToCharArray();
        System.Buffer.BlockCopy(chars, 2, bytes, 0, bytes.Length);

        return bytes;
    }
}

¿Alguien ve alguna razón para no hacer esto?

mystring.Select(Convert.ToByte).ToArray()

En primer lugar, agregue el System.Text nombres System.Text

using System.Text;

Entonces usa este código

string input = "some text"; 
byte[] array = Encoding.ASCII.GetBytes(input);

Espero arreglarlo!


Cuando trabajo con datos de sistemas Windows (con \r\n finales de línea), mi respuesta es

String = Bytes.decode("utf-8").replace("\r\n", "\n")

¿Por qué? Intente esto con un Input.txt multilínea:

Bytes = open("Input.txt", "rb").read()
String = Bytes.decode("utf-8")
open("Output.txt", "w").write(String)

Todas sus terminaciones de línea se duplicarán (a \r\r\n ), lo que dará lugar a líneas vacías adicionales. Las funciones de lectura de texto de Python normalmente normalizan los finales de línea para que las cadenas solo usen \n . Si recibe datos binarios de un sistema Windows, Python no tiene la oportunidad de hacerlo. Así,

Bytes = open("Input.txt", "rb").read()
String = Bytes.decode("utf-8").replace("\r\n", "\n")
open("Output.txt", "w").write(String)

replicará su archivo original.





c# string encoding byte