Me estoy convirtiendo algo de VB a C#. Teniendo un problema con la sintaxis de esta instrucción:

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

Entonces veo los errores siguientes:

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

El mejor método sobrecargado partido para
‘Sistema.Texto.De la codificación.GetString(byte[])’ tiene algunos argumentos no válidos

He intentado solucionar el código basado en este post, pero todavía sin éxito

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

Alguna sugerencia?

  • ¿Cuál es el tipo de searchResult.Properties["user"][0] ? Trate de fundición a byte[] primera
  • mshsayem fue donde yo iba. ¿Falta de un molde para un (byte[]) en el searchResult?
  • ¿Cómo puedo hacer que en mi caso? Mi conocimiento de la sintaxis de C# es muy limitada para ser honesto.
  • Usted necesita saber qué tipo Properties["user"][0] es. Si estás seguro de que es una matriz de bytes, entonces usted puede lanzar como este profile.User = System.Text.Encoding.UTF8.GetString((byte[])searchResult.Properties["user"][0]);
  • Necesito volver a consultar con el autor de el código original. Algo que parece faltar. Gracias por la ayuda de todos modos.
  • Resulta que no había ninguna necesidad de que todos los que alboroto. El nombre de usuario podría ser recuperado sin codificación, después de todo.
  • posibles duplicados de la Conversión de una Cadena de Matriz de bytes
  • ¿Por qué usted no seleccione una respuesta verdadera?

InformationsquelleAutor nouptime | 2013-04-18

13 Comentarios

  1. 963

    Si usted ya tiene una matriz de bytes, a continuación, usted debe saber qué tipo de codificación que se utilizó para realizar en dicha matriz de bytes.

    Por ejemplo, si la matriz de bytes fue creado como este:

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

    Necesitará volver a convertirlo en una cadena como esta:

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

    Si usted puede encontrar en el código heredado, la codificación que se utiliza para crear la matriz de bytes, entonces usted debe ser conjunto.

    • Timoteo, he mirado a través del código de VB y me parece que no puede encontrar una matriz de bytes como usted ha dicho.
    • En el resultado de la búsqueda, ¿cuál es el tipo de las Propiedades de la propiedad?
    • Todo lo que puedo ver es que hay un número de elementos conectados a las Propiedades como una cadena. No estoy seguro de si eso es lo que le estaban pidiendo a mí, sin embargo.
    • Esta solución no funciona con esta cadena «㯪» . pero #Erán Yogev solución funciona.
    • trate de Codificación.UTF8.GetBytes(somestring)
    • si ese byte de la matriz se produce a partir de una memoria de cadena de la lectura de un archivo, ¿qué debo usar?
    • ¿por qué no mystring.Seleccione(Convertir.ToByte).ToArray() ?
    • Si no se tiene cuidado con la codificación, puede utilizar Encoding.Default.GetBytes()
    • Para mi la situación me pareció que la Codificación.Unicode.GetBytes trabajado (pero ASCII no)

  2. 94

    Primero de todo, agregar el System.Text espacio de nombres

    using System.Text;

    A continuación, utilizar este código

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

    Esperanza para arreglarlo!

  3. 36

    También puede utilizar un Método de Extensión para añadir un método a la string tipo de la siguiente:

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

    Y utilizarlo como la siguiente:

    string foo = "bla bla";
    byte[] result = foo.ToByteArray();
    • Me gustaría cambiar el nombre que el método para incluir el hecho de que el uso de la codificación ASCII. Algo así como ToASCIIByteArray. Odio cuando me descubre algunos de la biblioteca estoy usando utiliza ASCII y estoy asumiendo que es el uso de UTF-8 o algo más moderno.
  4. 21
    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);
    }
    • Esto se producirá por personajes que caen en el par suplente gama.. GetBytes tendrá una matriz de bytes que se pierde uno normal char por par suplente fuera de la final. GetString tendrá vacío caracteres al final. La única manera de que el trabajo es si microsoft por defecto se UTF32, o si los caracteres en el par suplente rango no se les permitió. O es que hay algo que no estoy viendo? La forma correcta es ‘codificar’ de la cadena en bytes.
    • Correcto, para un rango más amplio puede utilizar algo similar a #Timoteo Randall’s solución: using System; using System.Text; namespace Ejemplo{ public class Programa { public static void Main(string[] args) { string s1 = «Hola Mundo»; string s2 = «שלום עולם»; string s3 = «你好,世界!»; La consola.WriteLine(Codificación.UTF8.GetString(Codificación.UTF8.GetBytes(s1))); Console.WriteLine(Codificación.UTF8.GetString(Codificación.UTF8.GetBytes(s2))); Console.WriteLine(Codificación.UTF8.GetString(Codificación.UTF8.GetBytes(s3))); } } }
  5. 20
    var result = System.Text.Encoding.Unicode.GetBytes(text);
    • Esto debe ser aceptado respuesta, como las otras respuestas sugieren ASCII, pero la codificación Unicode (que UTF16) o UTF8.
  6. 10

    El siguiente método sólo funcionará si los caracteres son de 1 byte. (Predeterminado unicode no funciona 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;
    }

    Mantenerlo simple

    • char y string son UTF-16, por definición.
    • Sí el valor por defecto es UTF-16. No estoy haciendo ninguna hipótesis sobre la Codificación de la cadena de entrada.
    • No hay ningún texto, sino de texto codificado. Su entrada es de tipo string y es, por tanto, UTF-16. UTF-16 no es el predeterminado; no hay ninguna opción al respecto. Que luego se divide en char[], de código UTF-16 unidades. A continuación, llamar a Convertir.ToByte(Char), que sólo pasa a convertir U+0000 a U+00FF a ISO-8859-1, y destroza cualquier otros puntos de codificación.
    • Hace sentido. Gracias por la aclaración. La actualización de mi respuesta.
    • Creo que aún le faltan varios puntos esenciales. Centrarse en char siendo de 16 bits y Convert.ToByte() tirar la mitad de ellos.
    • Gracias por la captura de ese. Mi solución sólo funcionará si los caracteres pueden ser representados por 1 byte (ASCII)

  7. 7

    Edificio de Ali respuesta, me gustaría recomendar un método de extensión que permite opcionalmente pasar en la codificación que desea utilizar:

    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 utilizarlo como la siguiente:

    string foo = "bla bla";
    
    //default encoding
    byte[] default = foo.ToByteArray();
    
    //custom encoding
    byte[] unicode = foo.ToByteArray(Encoding.Unicode);
    • Tenga en cuenta que el uso de Encoding encoding = Encoding.Default resultados en un error de tiempo de compilación: CS1736 Default parameter value for 'encoding' must be a compile-time constant
  8. 6

    Un refinamiento a JustinStolle edición de (Erán Yogev del uso de BlockCopy).

    La solución propuesta es de hecho más rápido que el uso de la Codificación.
    El problema es que no funciona para la codificación de las matrices de bytes de desigual longitud.
    Como dado, se plantea una salida de obligado excepción.
    El aumento de la longitud por 1 deja un byte final cuando la decodificación de la secuencia.

    Para mí, la necesidad vino cuando quise codificar de DataTable a JSON.
    Yo estaba buscando una manera de codificar los campos binarios en cadenas de descodificación y de la cadena a byte[].

    Por tanto, he creado dos clases, una que se ajusta a la solución anterior (cuando la codificación de cadenas finas, debido a que las longitudes son siempre, incluso), y otro que se encarga de byte[] de codificación.

    He resuelto el desigual longitud problema mediante la adición de un único personaje que me diga si la longitud original de la matriz binaria era impar (‘1’) o incluso (‘0’)

    De la siguiente manera:

    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;
        }
    }
  9. 4

    ¿Alguien ve ninguna razón por qué no hacerlo?

    mystring.Select(Convert.ToByte).ToArray()
    • Convert.ToByte(char) no funciona como crees que es. El carácter '2' se convierte en el byte 2, no el byte que representa el carácter '2'. Uso mystring.Select(x => (byte)x).ToArray() lugar.
  10. 4

    Si el resultado de, ‘searchResult.Propiedades [ «usuario» ] [ 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 [] puede hacer uso de LINQ:

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

    Y a la inversa:

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

    Esta pregunta ha sido respondida suficientemente muchas veces, pero con C# 7.2 y la introducción de las Span tipo, hay una manera 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 codificación UTF-16 cadena (llamada «Unicode» en C# de la tierra).

    Rápida de la evaluación comparativa muestra que los métodos anteriores son aproximadamente 5 veces más rápido que su Codificación.Unicode.GetBytes(…)/GetString(…) de las implementaciones para las medianas cadenas (de 30 a 50 caracteres), y aún más rápido para las grandes cadenas. Estos métodos también parecen ser más rápido que el uso de punteros con el Mariscal.Copia(..) o Tampón.MemoryCopy(…).

  12. 0

    Este trabajo para mí, después de que me podría convertir a poner mi foto en un campo bytea en mi base de datos.

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

Dejar respuesta

Please enter your comment!
Please enter your name here