Estoy convirtiendo algo de VB a 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 sobrecargado para 'System.Text.Encoding.GetString (byte [])' tiene algunos argumentos no válidos

Traté de arreglar el código basado en esta publicación, pero aún no tuve éxito

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

¿Alguna sugerencia?

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 se creó así:

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

Tendrá que 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 debe estar configurada.

En primer lugar, agregue el System.Textespacio de nombres

using System.Text;

Entonces usa este código

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

¡Espero arreglarlo!

También puede usar un Método de extensión para agregar un método al stringtipo de la siguiente manera:

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

Y úsalo como a continuación:

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

var result = System.Text.Encoding.Unicode.GetBytes(text);

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

¿Por qué no se debe usar Encoding.Default?

La respuesta de @ Randall utiliza Encoding.Default, sin embargo, Microsoft hace una advertencia en su contra :

Diferentes computadoras pueden usar diferentes codificaciones como predeterminadas, y la codificación predeterminada puede cambiar en una sola computadora. Si utiliza la codificación predeterminada para codificar y decodificar datos transmitidos entre computadoras o recuperados en diferentes momentos en la misma computadora, puede traducir esos datos incorrectamente. Además, la codificación devuelta por la propiedad Predeterminada utiliza el mejor respaldo para asignar caracteres no admitidos a caracteres admitidos por la página de códigos. Por estos motivos, no se recomienda utilizar la codificación predeterminada. Para garantizar que los bytes codificados se decodifiquen correctamente, debe usar una codificación Unicode, como UTF8Encoding o UnicodeEncoding. También puede usar un protocolo de nivel superior para garantizar que se use el mismo formato para codificar y decodificar.

Para verificar cuál es la codificación predeterminada, use Encoding.Default.WindowsCodePage(1250 en mi caso, y lamentablemente, no hay una clase predefinida de codificación CP1250, pero el objeto podría recuperarse como Encoding.GetEncoding(1250)).

Encoding.ASCII es de 7 bits, por lo que tampoco funciona, en mi caso:

byte[] pass = Encoding.ASCII.GetBytes("šarže");
Console.WriteLine(Encoding.ASCII.GetString(pass)); // ?ar?e

... y por qué la codificación UTF-8 debería usarse en su lugar ...

La codificación predeterminada es engañosa: .NET utiliza UTF-8 en todas partes como el valor predeterminado real (las codificaciones de 8 bits se volvieron obsoletas a finales de 20. siglo, marque ie Console.OutputEncoding.EncodingName*) por lo que cada constante que defina en el código está codificada de forma predeterminada UTF-8, por lo que este debe usarse a menos que la fuente de datos tenga una codificación diferente.

^{* Este es UTF-8 en mi caso, lo cual es una mentira directa: chcpdesde la consola de Windows (cmd) devuelve 852, y esto no debe cambiarse, porque los comandos del sistema localizados (como ping) tienen esta página de códigos codificada}

Siguiendo la recomendación de Microsoft:

var utf8 = new UTF8Encoding();
byte[] pass = utf8.GetBytes("šarže");
Console.WriteLine(utf8.GetString(pass)); // šarže

Encoding.UTF8 recomendado por otros es una instancia de codificación UTF-8 y también se puede usar directamente o como

var utf8 = Encoding.UTF8 as UTF8Encoding;

... pero no se usa siempre

La codificación de los conjuntos de bytes debería "funcionar" en Unicode en los países occidentales, pero tan pronto como mueva su programa a algunas regiones menos compatibles (como aquí en Europa del Este), es un verdadero desastre: en la República Checa, el uso predeterminado de Windows (¡en 2020!) MS no estándar 852 (también conocido como Latin-2) para consola, 1250 como OEM de Windows, UTF-8 (65001) como .NET (y otros) nuevo valor predeterminado y debemos tener en cuenta que algunos 8 bits de la UE occidental los datos todavía están en 1252, mientras que el antiguo estándar occidental de 8 bits para Europa del Este era ISO-8859-2 (también conocido como Latin-2, pero NO el mismo Latin-2 que 852). Usar ASCII significa texto lleno de tofu y '?' aquí. Entonces, hasta la mitad del siglo XXI, configure UTF-8 explícitamente .

A partir de la respuesta de Ali , recomendaría un método de extensión que le permita pasar opcionalmente la codificación que desea usar:

using System.Text;
public static class StringExtensions
{
    /// <summary>
    /// Creates a byte array from the string, using the 
    /// System.Text.Encoding.Default encoding unless another is specified.
    /// </summary>
    public static byte[] ToByteArray(this string str, Encoding encoding = Encoding.Default)
    {
        return encoding.GetBytes(str);
    }
}

Y úsalo como a continuación:

string foo = "bla bla";

// default encoding
byte[] default = foo.ToByteArray();

// custom encoding
byte[] unicode = foo.ToByteArray(Encoding.Unicode);

El siguiente enfoque funcionará solo si los caracteres son de 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

utilizar este

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

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

La solución propuesta es de hecho más rápida que usar la codificación. El problema es que no funciona para codificar conjuntos de bytes de longitud desigual. Según lo dado, plantea una excepción fuera de límite. Aumentar la longitud en 1 deja un byte final al decodificar desde una cadena.

Para mí, la necesidad vino cuando quería codificar de DataTablea JSON. Estaba buscando una manera 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 byte[] codificación.

Resolví el problema de longitud desigual agregando un solo carácter que me indica si la longitud original de la matriz binaria era impar ('1') o par ('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;
    }
}

Esta pregunta ha sido respondida muchas veces, pero con C # 7.2 y la introducción del tipo Span, hay una forma más rápida de hacer esto en código inseguro:

public static class StringSupport
{
    private static readonly int _charSize = sizeof(char);

    public static unsafe byte[] GetBytes(string str)
    {
        if (str == null) throw new ArgumentNullException(nameof(str));
        if (str.Length == 0) return new byte[0];

        fixed (char* p = str)
        {
            return new Span<byte>(p, str.Length * _charSize).ToArray();
        }
    }

    public static unsafe string GetString(byte[] bytes)
    {
        if (bytes == null) throw new ArgumentNullException(nameof(bytes));
        if (bytes.Length % _charSize != 0) throw new ArgumentException($"Invalid {nameof(bytes)} length");
        if (bytes.Length == 0) return string.Empty;

        fixed (byte* p = bytes)
        {
            return new string(new Span<char>(p, bytes.Length / _charSize));
        }
    }
}

Tenga en cuenta que los bytes representan una cadena codificada UTF-16 (llamada "Unicode" en C # land).

Algunas evaluaciones comparativas rápidas muestran que los métodos anteriores son aproximadamente 5 veces más rápidos que sus implementaciones Encoding.Unicode.GetBytes (...) / GetString (...) para cadenas de tamaño mediano (30-50 caracteres), e incluso más rápido para cadenas más grandes. Estos métodos también parecen ser más rápidos que usar punteros con Marshal.Copy (..) o Buffer.MemoryCopy (...).

Si el resultado de 'searchResult.Properties ["user"] [0]', es una cadena:

if ( ( searchResult.Properties [ "user" ].Count > 0 ) ) {

   profile.User = System.Text.Encoding.UTF8.GetString ( searchResult.Properties [ "user" ] [ 0 ].ToCharArray ().Select ( character => ( byte ) character ).ToArray () );

}

El punto clave es que la conversión de una cadena a un byte [] se puede hacer usando LINQ:

.ToCharArray ().Select ( character => ( byte ) character ).ToArray () )

Y lo contrario:

.Select ( character => ( char ) character ).ToArray () )

¿Alguien ve alguna razón por la que no hacer esto?

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

Esto me funcionó

byte[] bytes = Convert.FromBase64String(textString);

Puede usar la API MemoryMarshal para realizar una conversión muy rápida y eficiente. Stringse convertirá implícitamente en ReadOnlySpan<byte>, ya MemoryMarshal.Castsea como acepta Span<byte>o ReadOnlySpan<byte>como parámetro de entrada.

public static class StringExtensions
{
    public static byte[] ToByteArray(this string s) => s.ToByteSpan().ToArray(); //  heap allocation, use only when you cannot operate on spans
    public static ReadOnlySpan<byte> ToByteSpan(this string s) => MemoryMarshal.Cast<char, byte>(s);
}

El siguiente punto de referencia muestra la diferencia:

Input: "Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s,"

|                       Method |       Mean |     Error |    StdDev |  Gen 0 | Gen 1 | Gen 2 | Allocated |
|----------------------------- |-----------:|----------:|----------:|-------:|------:|------:|----------:|
| UsingEncodingUnicodeGetBytes | 160.042 ns | 3.2864 ns | 6.4099 ns | 0.0780 |     - |     - |     328 B |
| UsingMemoryMarshalAndToArray |  31.977 ns | 0.7177 ns | 1.5753 ns | 0.0781 |     - |     - |     328 B |
|           UsingMemoryMarshal |   1.027 ns | 0.0565 ns | 0.1630 ns |      - |     - |     - |         - |

Esto funcionó para mí, después de eso pude convertir poner mi imagen en un campo bytea en mi base de datos.

using (MemoryStream s = new MemoryStream(DirEntry.Properties["thumbnailphoto"].Value as byte[]))
{
    return s.ToArray();
}