Estou convertendo algo do VB para C #. Tendo um problema com a sintaxe desta declaração:

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

Eu vejo os seguintes erros:

Argumento 1: não é possível converter de 'objeto' para 'byte []'

A melhor correspondência de método sobrecarregado para 'System.Text.Encoding.GetString (byte [])' possui alguns argumentos inválidos

Tentei corrigir o código com base nesta postagem, mas ainda não obtive sucesso

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

Alguma sugestão?

Se você já possui uma matriz de bytes, precisará saber que tipo de codificação foi usada para inseri-la nessa matriz de bytes.

Por exemplo, se a matriz de bytes foi criada assim:

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

Você precisará transformá-lo novamente em uma string como esta:

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

Se você pode encontrar no código que herdou, a codificação usada para criar a matriz de bytes, então você deve estar definido.

Primeiro de tudo, adicione o System.Textespaço para nome

using System.Text;

Então use este código

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

Espero consertar!

Além disso, você pode usar um método de extensão para adicionar um método ao stringtipo como abaixo:

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

E use-o como abaixo:

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 que Encoding.Default não deve ser usado ...

A resposta de @ Randall é usada Encoding.Default, no entanto, a Microsoft lança um aviso contra :

Computadores diferentes podem usar codificações diferentes como padrão e a codificação padrão pode ser alterada em um único computador. Se você usar a codificação padrão para codificar e decodificar dados transmitidos entre computadores ou recuperados em momentos diferentes no mesmo computador, isso poderá traduzir esses dados incorretamente. Além disso, a codificação retornada pela propriedade Padrão usa o fallback de melhor ajuste para mapear caracteres não suportados para caracteres suportados pela página de código. Por esses motivos, o uso da codificação padrão não é recomendado. Para garantir que os bytes codificados sejam decodificados corretamente, você deve usar uma codificação Unicode, como UTF8Encoding ou UnicodeEncoding. Você também pode usar um protocolo de nível superior para garantir que o mesmo formato seja usado para codificação e decodificação.

Para verificar qual é a codificação padrão, use Encoding.Default.WindowsCodePage(1250 no meu caso - e, infelizmente, não há classe predefinida de codificação CP1250, mas o objeto pode ser recuperado comoEncoding.GetEncoding(1250) ).

Encoding.ASCII é 7bit, então também não funciona, no meu caso:

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

... e por que a codificação UTF-8 deve ser usada ...

A codificação padrão é enganosa: o .NET usa UTF-8 em todos os lugares como o padrão real (codificações de 8 bits se tornaram obsoletas no final do século 20. verifique Console.OutputEncoding.EncodingName *) para que todas as constantes definidas no código sejam codificadas em UTF-8 por padrão - portanto este deve ser usado, a menos que a fonte de dados esteja em codificação diferente.

^{* Este é UTF-8 no meu caso, o que é uma mentira direta: chcp do console do Windows (cmd) retorna 852 - e isso não deve ser alterado, porque os comandos do sistema localizado (como ping) possuem essa página de código codificada}

Seguindo a recomendação da Microsoft:

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

Encoding.UTF8 recomendado por outras pessoas é uma instância de codificação UTF-8 e também pode ser usado diretamente ou como

var utf8 = Encoding.UTF8 as UTF8Encoding;

... mas nem sempre é usado

A codificação para matrizes de bytes deve "apenas funcionar" em Unicode nos países ocidentais, mas assim que você move o programa para algumas regiões com menos suporte (como aqui na Europa Oriental), é uma verdadeira bagunça: na República Tcheca, os padrões do Windows usam (em 2020!) MS não-padrão 852 (também conhecido como Latin-2) para console, 1250 como Windows OEM, UTF-8 (65001) como .NET (e outros) novo padrão e devemos ter em mente que alguns países de 8 bits da UE ocidental os dados ainda estão em 1252, enquanto o antigo padrão ocidental de 8 bits da Europa Oriental era ISO-8859-2 (também conhecido como Latin-2, mas NÃO o mesmo Latin-2 que 852). Usar ASCII significa texto cheio de tofu e '?' aqui. Portanto, até a metade do século XXI, defina UTF-8 explicitamente .

Com base na resposta de Ali , eu recomendaria um método de extensão que permita passar opcionalmente a codificação que você deseja 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);
    }
}

E use-o como abaixo:

string foo = "bla bla";

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

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

A abordagem a seguir funcionará apenas se os caracteres tiverem 1 byte. (O unicode padrão não funcionará, pois tem 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;
}

Mantendo as coisas simples

usa isto

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

Um refinamento para a edição de JustinStolle (uso de BlockCopy por Eran Yogev).

A solução proposta é realmente mais rápida do que usar Encoding. O problema é que ele não funciona para codificar matrizes de bytes de comprimento desigual. Como dado, gera uma exceção fora dos limites. Aumentar o comprimento em 1 deixa um byte à direita ao decodificar da string.

Para mim, surgiu a necessidade quando eu queria codificar de DataTablepara JSON. Eu estava procurando uma maneira de codificar campos binários em strings e decodificar da string de volta para byte[].

Portanto, criei duas classes - uma que envolve a solução acima (ao codificar a partir de seqüências de caracteres, tudo bem, porque os comprimentos são sempre pares) e outra que lida com a byte[]codificação.

Resolvi o problema de comprimento irregular adicionando um único caractere que informa se o comprimento original da matriz binária era ímpar ('1') ou par ('0')

Do seguinte modo:

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 pergunta foi respondida várias vezes, mas com o C # 7.2 e a introdução do tipo Span, há uma maneira mais rápida de fazer isso no código não seguro:

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

Lembre-se de que os bytes representam uma sequência codificada em UTF-16 (chamada "Unicode" em C # land).

Alguns testes rápidos mostram que os métodos acima são aproximadamente 5x mais rápidos que suas implementações Encoding.Unicode.GetBytes (...) / GetString (...) para cadeias de tamanho médio (30 a 50 caracteres) e ainda mais rápidas para cadeias de caracteres maiores. Esses métodos também parecem ser mais rápidos do que usar ponteiros com Marshal.Copy (..) ou Buffer.MemoryCopy (...).

Se o resultado de 'searchResult.Properties ["user"] [0]', for uma sequência:

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

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

}

O ponto principal é que a conversão de uma string em um byte [] pode ser feita usando o LINQ:

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

E o inverso:

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

Alguém vê alguma razão para não fazer isso?

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

Isso que funcionou para mim

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

Você pode usar a API MemoryMarshal para realizar uma conversão muito rápida e eficiente. Stringserá implicitamente convertido para ReadOnlySpan<byte>, como MemoryMarshal.Castaceita um Span<byte>ou ReadOnlySpan<byte>como um 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);
}

O benchmark a seguir mostra a diferença:

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

Este trabalho para mim, depois disso eu pude converter colocar minha foto em um campo bytea no meu banco de dados.

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