Ich konvertiere etwas von VB in C #. Ein Problem mit der Syntax dieser Anweisung:

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

Ich sehe dann folgende Fehler:

Argument 1: Konvertierung von 'Objekt' in 'Byte []' nicht möglich

Die beste überladene Methodenübereinstimmung für 'System.Text.Encoding.GetString (byte [])' enthält einige ungültige Argumente

Ich habe versucht, den Code basierend auf diesem Beitrag zu korrigieren , aber immer noch keinen Erfolg

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

Irgendwelche Vorschläge?

Wenn Sie bereits ein Byte-Array haben, müssen Sie wissen, welche Art von Codierung verwendet wurde, um es in dieses Byte-Array zu verwandeln.

Wenn das Byte-Array beispielsweise folgendermaßen erstellt wurde:

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

Sie müssen es wieder in eine Zeichenfolge wie die folgende umwandeln:

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

Wenn Sie in dem von Ihnen geerbten Code die Codierung finden, die zum Erstellen des Byte-Arrays verwendet wurde, sollten Sie festgelegt werden.

Fügen Sie zunächst den System.TextNamespace hinzu

using System.Text;

Verwenden Sie dann diesen Code

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

Hoffe es zu beheben!

Sie können auch eine Erweiterungsmethode verwenden , um dem stringTyp eine Methode wie folgt hinzuzufügen :

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

Und benutze es wie folgt:

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

Warum Encoding.Default nicht verwendet werden sollte ...

@ Randalls Antwort verwendet Encoding.Default, aber Microsoft warnt davor :

Verschiedene Computer können standardmäßig unterschiedliche Codierungen verwenden, und die Standardcodierung kann sich auf einem einzelnen Computer ändern. Wenn Sie die Standardcodierung verwenden, um Daten zu codieren und zu decodieren, die zwischen Computern gestreamt oder zu unterschiedlichen Zeiten auf demselben Computer abgerufen werden, werden diese Daten möglicherweise falsch übersetzt. Darüber hinaus verwendet die von der Default-Eigenschaft zurückgegebene Codierung den Best-Fit-Fallback, um nicht unterstützte Zeichen Zeichen zuzuordnen, die von der Codepage unterstützt werden. Aus diesen Gründen wird die Verwendung der Standardcodierung nicht empfohlen. Um sicherzustellen, dass codierte Bytes ordnungsgemäß decodiert werden, sollten Sie eine Unicode-Codierung verwenden, z. B. UTF8Encoding oder UnicodeEncoding. Sie können auch ein übergeordnetes Protokoll verwenden, um sicherzustellen, dass für die Codierung und Decodierung dasselbe Format verwendet wird.

Verwenden Sie Encoding.Default.WindowsCodePage(in meinem Fall 1250 - und leider gibt es keine vordefinierte Klasse der CP1250-Codierung, aber das Objekt kann als abgerufen werden Encoding.GetEncoding(1250)), um die Standardcodierung zu überprüfen .

Encoding.ASCII ist 7bit, also funktioniert es auch nicht, in meinem Fall:

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

... und warum stattdessen UTF-8-Codierung verwendet werden sollte ...

Die Standardcodierung ist irreführend: .NET verwendet UTF-8 überall als Standard (8-Bit-Codierungen sind Ende des 20. Jahrhunderts veraltet, überprüfen Sie dh Console.OutputEncoding.EncodingName*), sodass jede im Code definierte Konstante standardmäßig UTF-8-codiert ist Dieser sollte verwendet werden, es sei denn, die Datenquelle hat eine andere Codierung.

^{* Dies ist in meinem Fall UTF-8, was eine direkte Lüge ist: chcpVon der Windows-Konsole (cmd) wird 852 zurückgegeben - und dies sollte nicht geändert werden, da bei lokalisierten Systembefehlen (wie Ping) diese Codepage fest codiert ist}

Befolgen Sie die Empfehlung von Microsoft:

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

Encoding.UTF8 Von anderen empfohlen wird eine Instanz der UTF-8-Codierung, die auch direkt oder als verwendet werden kann

var utf8 = Encoding.UTF8 as UTF8Encoding;

... aber es wird nicht immer verwendet

Die Codierung für Byte-Arrays sollte in westlichen Ländern in Unicode "nur funktionieren". Sobald Sie Ihr Programm jedoch in weniger unterstützte Regionen (wie hier in Osteuropa) verschieben, ist dies ein echtes Chaos: In der Tschechischen Republik wird Windows standardmäßig verwendet (im Jahr 2020!) MS nicht Standard 852 (auch bekannt als Latin-2) für Konsole, 1250 als Windows OEM, UTF-8 (65001) als .NET (und andere) neuer Standard und wir sollten bedenken, dass einige westliche EU 8bit Daten sind noch im Jahr 1252, während der alte 8-Bit-Weststandard für Osteuropa ISO-8859-2 war (auch bekannt als Latin-2, aber NICHT das gleiche Latin-2 wie 852). Die Verwendung von ASCII bedeutet Text voller Tofu und '?' Hier. Stellen Sie UTF-8 also bis zur Hälfte des 21. Jahrhunderts explizit ein .

Aufbauend auf Alis Antwort würde ich eine Erweiterungsmethode empfehlen, mit der Sie optional die Codierung übergeben können, die Sie verwenden möchten:

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

Und benutze es wie folgt:

string foo = "bla bla";

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

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

Der folgende Ansatz funktioniert nur, wenn die Zeichen 1 Byte groß sind. (Standard-Unicode funktioniert nicht, da es 2 Bytes sind)

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

Einfach halten

benutze das

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

Eine Verfeinerung der Bearbeitung von JustinStolle (Eran Yogevs Verwendung von BlockCopy).

Die vorgeschlagene Lösung ist in der Tat schneller als die Verwendung der Codierung. Das Problem ist, dass es nicht zum Codieren von Byte-Arrays mit ungleicher Länge funktioniert. Wie angegeben, wird eine Out-of-Bound-Ausnahme ausgelöst. Wenn Sie die Länge um 1 erhöhen, bleibt beim Dekodieren aus einem String ein nachfolgendes Byte übrig.

Für mich kam die Notwendigkeit , als ich zu kodieren von wollte DataTablezu JSON. Ich suchte nach einer Möglichkeit, Binärfelder in Strings zu codieren und von String zurück zu zu decodieren byte[].

Ich habe daher zwei Klassen erstellt - eine, die die obige Lösung umschließt (beim Codieren aus Zeichenfolgen ist dies in Ordnung, da die Längen immer gerade sind), und eine andere, die das byte[]Codieren übernimmt .

Ich habe das Problem der ungleichmäßigen Länge gelöst, indem ich ein einzelnes Zeichen hinzugefügt habe, das mir sagt, ob die ursprüngliche Länge des binären Arrays ungerade ('1') oder gerade ('0') war.

Wie folgt:

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

Diese Frage wurde ausreichend oft beantwortet, aber mit C # 7.2 und der Einführung des Span-Typs gibt es eine schnellere Möglichkeit, dies in unsicherem Code zu tun:

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

Beachten Sie, dass die Bytes eine UTF-16-codierte Zeichenfolge darstellen (in C # -Land "Unicode" genannt).

Einige schnelle Benchmarking-Tests zeigen, dass die oben genannten Methoden ungefähr fünfmal schneller sind als die Implementierungen Encoding.Unicode.GetBytes (...) / GetString (...) für mittelgroße Zeichenfolgen (30-50 Zeichen) und sogar noch schneller für größere Zeichenfolgen. Diese Methoden scheinen auch schneller zu sein als die Verwendung von Zeigern mit Marshal.Copy (..) oder Buffer.MemoryCopy (...).

Wenn das Ergebnis von 'searchResult.Properties ["user"] [0]' eine Zeichenfolge ist:

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

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

}

Der entscheidende Punkt ist, dass die Konvertierung eines Strings in ein Byte [] mit LINQ erfolgen kann:

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

Und umgekehrt:

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

Hat jemand einen Grund, dies nicht zu tun?

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

Das hat bei mir funktioniert

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

Sie können die MemoryMarshal-API verwenden , um eine sehr schnelle und effiziente Konvertierung durchzuführen. Stringwird implizit umgewandelt ReadOnlySpan<byte>, als MemoryMarshal.Castentweder Span<byte>oder ReadOnlySpan<byte>als Eingabeparameter akzeptiert .

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

Der folgende Benchmark zeigt den Unterschied:

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

Diese Arbeit für mich, danach konnte ich mein Bild in ein Bytea-Feld in meiner Datenbank konvertieren.

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