Wie konvertiere ich eine stringin eine byte[]in .NET (C #), ohne manuell eine bestimmte Codierung anzugeben?

Ich werde die Zeichenfolge verschlüsseln. Ich kann es verschlüsseln, ohne es zu konvertieren, aber ich möchte trotzdem wissen, warum hier die Codierung zum Tragen kommt.

Warum sollte die Kodierung überhaupt berücksichtigt werden? Kann ich nicht einfach abrufen, in welchen Bytes die Zeichenfolge gespeichert wurde? Warum besteht eine Abhängigkeit von Zeichenkodierungen?

Im Gegensatz zu den Antworten hier müssen Sie sich keine Gedanken über die Codierung machen, wenn die Bytes nicht interpretiert werden müssen!

Wie Sie bereits erwähnt haben, besteht Ihr Ziel einfach darin, "herauszufinden, in welchen Bytes die Zeichenfolge gespeichert wurde" .
(Und natürlich, um den String aus den Bytes rekonstruieren zu können.)

Für diese Ziele verstehe ich ehrlich gesagt nicht , warum die Leute Ihnen immer wieder sagen, dass Sie die Kodierungen benötigen. Sie müssen sich hierfür KEINE Gedanken über Codierungen machen.

Tun Sie dies stattdessen einfach:

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

// Do NOT use on arbitrary bytes; only use on GetBytes's output on the SAME system
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);
}

Solange Ihr Programm (oder andere Programme) nicht versucht, die Bytes irgendwie zu interpretieren , was Sie offensichtlich nicht erwähnt haben, ist an diesem Ansatz nichts auszusetzen! Wenn Sie sich um Kodierungen sorgen, wird Ihr Leben ohne wirklichen Grund komplizierter.

Zusätzlicher Vorteil dieses Ansatzes:

Es spielt keine Rolle, ob die Zeichenfolge ungültige Zeichen enthält, da Sie die Daten trotzdem abrufen und die ursprüngliche Zeichenfolge rekonstruieren können!

Es wird trotzdem codiert und decodiert, da Sie nur die Bytes betrachten .

Wenn Sie jedoch eine bestimmte Codierung verwendet hätten, hätten Sie Probleme beim Codieren / Decodieren ungültiger Zeichen.

Dies hängt von der Codierung Ihrer Zeichenfolge ab ( ASCII , UTF-8 , ...).

Zum Beispiel:

byte[] b1 = System.Text.Encoding.UTF8.GetBytes (myString);
byte[] b2 = System.Text.Encoding.ASCII.GetBytes (myString);

Ein kleines Beispiel, warum Codierung wichtig ist:

string pi = "\u03a0";
byte[] ascii = System.Text.Encoding.ASCII.GetBytes (pi);
byte[] utf8 = System.Text.Encoding.UTF8.GetBytes (pi);

Console.WriteLine (ascii.Length); //Will print 1
Console.WriteLine (utf8.Length); //Will print 2
Console.WriteLine (System.Text.Encoding.ASCII.GetString (ascii)); //Will print '?'

ASCII ist einfach nicht für Sonderzeichen gerüstet.

Intern verwendet das .NET-Framework UTF-16 zur Darstellung von Zeichenfolgen. Wenn Sie also einfach die genauen Bytes abrufen möchten, die .NET verwendet, verwenden Sie System.Text.Encoding.Unicode.GetBytes (...).

Weitere Informationen finden Sie unter Zeichenkodierung in .NET Framework (MSDN).

Die akzeptierte Antwort ist sehr, sehr kompliziert. Verwenden Sie dazu die enthaltenen .NET-Klassen:

const string data = "A string with international characters: Norwegian: ÆØÅæøå, Chinese: 喂 谢谢";
var bytes = System.Text.Encoding.UTF8.GetBytes(data);
var decoded = System.Text.Encoding.UTF8.GetString(bytes);

Erfinden Sie das Rad nicht neu, wenn Sie nicht ...

BinaryFormatter bf = new BinaryFormatter();
byte[] bytes;
MemoryStream ms = new MemoryStream();

string orig = "喂 Hello 谢谢 Thank You";
bf.Serialize(ms, orig);
ms.Seek(0, 0);
bytes = ms.ToArray();

MessageBox.Show("Original bytes Length: " + bytes.Length.ToString());

MessageBox.Show("Original string Length: " + orig.Length.ToString());

for (int i = 0; i < bytes.Length; ++i) bytes[i] ^= 168; // pseudo encrypt
for (int i = 0; i < bytes.Length; ++i) bytes[i] ^= 168; // pseudo decrypt

BinaryFormatter bfx = new BinaryFormatter();
MemoryStream msx = new MemoryStream();            
msx.Write(bytes, 0, bytes.Length);
msx.Seek(0, 0);
string sx = (string)bfx.Deserialize(msx);

MessageBox.Show("Still intact :" + sx);

MessageBox.Show("Deserialize string Length(still intact): " 
    + sx.Length.ToString());

BinaryFormatter bfy = new BinaryFormatter();
MemoryStream msy = new MemoryStream();
bfy.Serialize(msy, sx);
msy.Seek(0, 0);
byte[] bytesy = msy.ToArray();

MessageBox.Show("Deserialize bytes Length(still intact): " 
   + bytesy.Length.ToString());

Sie müssen die Codierung berücksichtigen, da 1 Zeichen durch 1 oder mehr Bytes (bis zu etwa 6) dargestellt werden kann und unterschiedliche Codierungen diese Bytes unterschiedlich behandeln.

Joel hat einen Beitrag dazu:

Das absolute Minimum Jeder Softwareentwickler muss unbedingt positiv über Unicode und Zeichensätze Bescheid wissen (keine Ausreden!)

Dies ist eine beliebte Frage. Es ist wichtig zu verstehen, was der Autor der Frage stellt und dass es sich von dem unterscheidet, was wahrscheinlich am häufigsten benötigt wird. Um den Missbrauch des Codes dort zu verhindern, wo er nicht benötigt wird, habe ich den späteren zuerst beantwortet.

Gemeinsames Bedürfnis

Jede Zeichenfolge hat einen Zeichensatz und eine Codierung. Wenn Sie ein System.StringObjekt in ein Array von konvertieren, System.Bytehaben Sie immer noch einen Zeichensatz und eine Codierung. Für die meisten Anwendungen wissen Sie, welchen Zeichensatz und welche Codierung Sie benötigen, und .NET macht es einfach, "mit Konvertierung zu kopieren". Wählen Sie einfach die entsprechende EncodingKlasse.

// using System.Text;
Encoding.UTF8.GetBytes(".NET String to byte array")

Die Konvertierung muss möglicherweise Fälle behandeln, in denen der Zielzeichensatz oder die Codierung kein Zeichen in der Quelle unterstützt. Sie haben einige Möglichkeiten: Ausnahme, Ersetzung oder Überspringen. Die Standardrichtlinie besteht darin, ein '?' Zu ersetzen.

// using System.Text;
var text = Encoding.ASCII.GetString(Encoding.ASCII.GetBytes("You win €100")); 
                                                      // -> "You win ?100"

Conversions sind natürlich nicht unbedingt verlustfrei!

Hinweis: System.StringDer Quellzeichensatz ist Unicode.

Das einzig Verwirrende ist, dass .NET den Namen eines Zeichensatzes für den Namen einer bestimmten Codierung dieses Zeichensatzes verwendet. Encoding.Unicodesollte aufgerufen werden Encoding.UTF16.

Das war's für die meisten Verwendungen. Wenn Sie das brauchen, hören Sie hier auf zu lesen. Lesen Sie den lustigen Artikel von Joel Spolsky, wenn Sie nicht verstehen, was eine Codierung ist.

Spezifischer Bedarf

Nun fragt der Autor der Frage: "Jede Zeichenfolge wird als Array von Bytes gespeichert, richtig? Warum kann ich diese Bytes nicht einfach haben?"

Er will keine Bekehrung.

Aus der C # -Spezifikation :

Die Zeichen- und Zeichenfolgenverarbeitung in C # verwendet die Unicode-Codierung. Der Zeichentyp repräsentiert eine UTF-16-Codeeinheit, und der Zeichenfolgentyp repräsentiert eine Folge von UTF-16-Codeeinheiten.

Wir wissen also, dass wir das gewünschte Ergebnis erhalten, wenn wir nach der Nullkonvertierung fragen (dh von UTF-16 nach UTF-16):

Encoding.Unicode.GetBytes(".NET String to byte array")

Aber um die Erwähnung von Kodierungen zu vermeiden, müssen wir es anders machen. Wenn ein Zwischendatentyp akzeptabel ist, gibt es dafür eine konzeptionelle Verknüpfung:

".NET String to byte array".ToCharArray()

Das bringt uns nicht den gewünschten Datentyp, aber Mehrdads Antwort zeigt, wie dieses Char-Array mit BlockCopy in ein Byte-Array konvertiert wird . Dies kopiert die Zeichenfolge jedoch zweimal! Außerdem wird explizit codierungsspezifischer Code verwendet: der Datentyp System.Char.

Der einzige Weg, um zu den tatsächlichen Bytes zu gelangen, in denen der String gespeichert ist, ist die Verwendung eines Zeigers. Die fixedAnweisung ermöglicht die Angabe der Adresse von Werten. Aus der C # -Spezifikation:

[Für] einen Ausdruck vom Typ Zeichenfolge, ... berechnet der Initialisierer die Adresse des ersten Zeichens in der Zeichenfolge.

Zu diesem Zweck schreibt der Compiler Code, der die anderen Teile des Zeichenfolgenobjekts mit überspringt RuntimeHelpers.OffsetToStringData. Um die Rohbytes zu erhalten, erstellen Sie einfach einen Zeiger auf die Zeichenfolge und kopieren Sie die Anzahl der benötigten Bytes.

// using System.Runtime.InteropServices
unsafe byte[] GetRawBytes(String s)
{
    if (s == null) return null;
    var codeunitCount = s.Length;
    /* We know that String is a sequence of UTF-16 codeunits 
       and such codeunits are 2 bytes */
    var byteCount = codeunitCount * 2; 
    var bytes = new byte[byteCount];
    fixed(void* pRaw = s)
    {
        Marshal.Copy((IntPtr)pRaw, bytes, 0, byteCount);
    }
    return bytes;
}

Wie @CodesInChaos hervorhob, hängt das Ergebnis von der Endianness der Maschine ab. Aber der Fragesteller befasst sich nicht damit.

Der erste Teil Ihrer Frage (wie man die Bytes erhält) wurde bereits von anderen beantwortet: Schauen Sie in den System.Text.EncodingNamespace.

Ich werde auf Ihre Folgefrage eingehen: Warum müssen Sie eine Codierung auswählen? Warum können Sie das nicht von der String-Klasse selbst bekommen?

Die Antwort besteht aus zwei Teilen.

Erstens spielen die von der Zeichenfolgenklasse intern verwendeten Bytes keine Rolle , und wann immer Sie davon ausgehen, dass dies der Fall ist, führen Sie wahrscheinlich einen Fehler ein.

Wenn sich Ihr Programm vollständig in der .NET-Welt befindet, müssen Sie sich keine Gedanken darüber machen, ob Sie Byte-Arrays für Zeichenfolgen erhalten, selbst wenn Sie Daten über ein Netzwerk senden. Verwenden Sie stattdessen .Net Serialization, um sich Gedanken über die Übertragung der Daten zu machen. Sie kümmern sich nicht mehr um die tatsächlichen Bytes: Der Serialisierungsformatierer erledigt dies für Sie.

Was ist andererseits, wenn Sie diese Bytes an einen Ort senden, von dem Sie nicht garantieren können, dass sie Daten aus einem serialisierten .Net-Stream abrufen? In diesem Fall müssen Sie sich definitiv um die Codierung kümmern, da sich dieses externe System offensichtlich darum kümmert. Auch hier spielen die von der Zeichenfolge verwendeten internen Bytes keine Rolle: Sie müssen eine Codierung auswählen, damit Sie diese Codierung auf der Empfangsseite explizit angeben können, selbst wenn es sich um dieselbe Codierung handelt, die intern von .Net verwendet wird.

Ich verstehe, dass Sie in diesem Fall möglicherweise die tatsächlichen Bytes verwenden möchten, die von der Zeichenfolgenvariablen im Speicher gespeichert werden, wenn dies möglich ist, mit der Idee, dass dadurch möglicherweise etwas Arbeit beim Erstellen Ihres Bytestreams gespart wird. Ich sage es Ihnen jedoch, es ist einfach nicht wichtig, um sicherzustellen, dass Ihre Ausgabe am anderen Ende verstanden wird, und um sicherzustellen, dass Sie mit Ihrer Codierung explizit sein müssen . Wenn Sie wirklich mit Ihren internen Bytes übereinstimmen möchten, können Sie bereits die UnicodeCodierung auswählen und so Leistungseinsparungen erzielen.

Das bringt mich zum zweiten Teil ... die Kommissionierung UnicodeCodierung wird sagen , .Net , die zugrunde liegende Bytes zu verwenden. Sie müssen diese Codierung auswählen, da die .Net-Laufzeit frei sein muss, um dieses neuere, bessere Codierungsmodell zu verwenden, ohne Ihr Programm zu beschädigen, wenn ein neues Unicode-Plus herauskommt. Für den Moment (und die absehbare Zukunft) erhalten Sie jedoch nur das, was Sie möchten, wenn Sie nur die Unicode-Codierung auswählen.

Es ist auch wichtig zu verstehen, dass Ihre Zeichenfolge neu in Wire geschrieben werden muss, und dies beinhaltet zumindest eine gewisse Übersetzung des Bitmusters, selbst wenn Sie eine passende Codierung verwenden . Der Computer muss Dinge wie Big vs Little Endian, Netzwerkbyte-Reihenfolge, Paketierung, Sitzungsinformationen usw. berücksichtigen.

Um zu demonstrieren, dass Mehrdrads fundierte Antwort funktioniert, kann sein Ansatz sogar die ungepaarten Ersatzzeichen beibehalten (von denen sich viele gegen meine Antwort geeinigt hatten, von denen jedoch alle gleichermaßen schuldig sind, z. B. System.Text.Encoding.UTF8.GetByteskönnen System.Text.Encoding.Unicode.GetBytesdiese Codierungsmethoden das hohe Ersatzzeichen nicht beibehalten Zeichen d800zum Beispiel, und diese ersetzen lediglich hohe Ersatzzeichen durch Wert fffd):

using System;

class Program
{     
    static void Main(string[] args)
    {
        string t = "爱虫";            
        string s = "Test\ud800Test"; 

        byte[] dumpToBytes = GetBytes(s);
        string getItBack = GetString(dumpToBytes);

        foreach (char item in getItBack)
        {
            Console.WriteLine("{0} {1}", item, ((ushort)item).ToString("x"));
        }    
    }

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

Ausgabe:

T 54
e 65
s 73
t 74
? d800
T 54
e 65
s 73
t 74

Versuchen Sie dies mit System.Text.Encoding.UTF8.GetBytes oder System.Text.Encoding.Unicode.GetBytes . Sie ersetzen lediglich hohe Ersatzzeichen durch den Wert fffd

Jedes Mal, wenn sich diese Frage bewegt, denke ich immer noch an einen Serializer (sei es von Microsoft oder von einer Komponente eines Drittanbieters), der Zeichenfolgen beibehalten kann, selbst wenn er ungepaarte Ersatzzeichen enthält. Ich google dies ab und zu: Serialisierung ungepaartes Ersatzzeichen .NET . Das lässt mich keinen Schlaf verlieren, aber es ist irgendwie ärgerlich, wenn ab und zu jemand meine Antwort kommentiert, dass sie fehlerhaft ist, aber ihre Antworten sind ebenso fehlerhaft, wenn es um ungepaarte Ersatzcharaktere geht.

Verdammt, Microsoft hätte gerade System.Buffer.BlockCopyin seinem BinaryFormatterツ verwenden sollen

谢谢！

Versuchen Sie dies, viel weniger Code:

System.Text.Encoding.UTF8.GetBytes("TEST String");

Nun, ich habe alle Antworten gelesen und es ging um die Verwendung von Codierung oder um Serialisierung, bei der ungepaarte Surrogate gelöscht werden.

Es ist schlecht, wenn die Zeichenfolge beispielsweise von SQL Server stammt, wo sie aus einem Byte-Array erstellt wurde, in dem beispielsweise ein Kennwort-Hash gespeichert ist. Wenn wir etwas daraus löschen, wird ein ungültiger Hash gespeichert, und wenn wir ihn in XML speichern möchten, möchten wir ihn intakt lassen (da der XML-Writer eine Ausnahme für jeden gefundenen ungepaarten Ersatz löscht).

In solchen Fällen verwende ich die Base64- Codierung von Byte-Arrays, aber hey, im Internet gibt es nur eine Lösung für dieses Problem in C #, und es enthält einen Fehler und ist nur eine Möglichkeit. Deshalb habe ich den Fehler behoben und zurückgeschrieben Verfahren. Hier sind Sie, zukünftige Googler:

public static byte[] StringToBytes(string str)
{
    byte[] data = new byte[str.Length * 2];
    for (int i = 0; i < str.Length; ++i)
    {
        char ch = str[i];
        data[i * 2] = (byte)(ch & 0xFF);
        data[i * 2 + 1] = (byte)((ch & 0xFF00) >> 8);
    }

    return data;
}

public static string StringFromBytes(byte[] arr)
{
    char[] ch = new char[arr.Length / 2];
    for (int i = 0; i < ch.Length; ++i)
    {
        ch[i] = (char)((int)arr[i * 2] + (((int)arr[i * 2 + 1]) << 8));
    }
    return new String(ch);
}

Bitte erläutern Sie auch, warum die Codierung berücksichtigt werden sollte. Kann ich nicht einfach abrufen, in welchen Bytes die Zeichenfolge gespeichert wurde? Warum diese Abhängigkeit von der Codierung? !!!

Weil es so etwas wie "die Bytes der Zeichenfolge" nicht gibt.

Eine Zeichenfolge (oder allgemeiner ein Text) besteht aus Zeichen: Buchstaben, Ziffern und anderen Symbolen. Das ist alles. Computer wissen jedoch nichts über Zeichen; Sie können nur Bytes verarbeiten. Wenn Sie Text mithilfe eines Computers speichern oder übertragen möchten, müssen Sie die Zeichen in Bytes umwandeln. Wie machst du das? Hier kommen Kodierungen ins Spiel.

Eine Codierung ist nichts anderes als eine Konvention, um logische Zeichen in physische Bytes zu übersetzen. Die einfachste und bekannteste Codierung ist ASCII, und es ist alles, was Sie brauchen, wenn Sie auf Englisch schreiben. Für andere Sprachen benötigen Sie vollständigere Codierungen, da jede der Unicode-Varianten heutzutage die sicherste Wahl ist.

Kurz gesagt, der Versuch, "die Bytes einer Zeichenfolge ohne Verwendung von Codierungen abzurufen", ist ebenso unmöglich wie "das Schreiben eines Textes ohne Verwendung einer Sprache".

Übrigens empfehle ich Ihnen (und jedem anderen) dringend, dieses kleine Stück Weisheit zu lesen: Das absolute Minimum, das jeder Softwareentwickler unbedingt über Unicode- und Zeichensätze wissen muss (keine Ausreden!)

C #, um a stringin ein byteArray zu konvertieren :

public static byte[] StrToByteArray(string str)
{
   System.Text.UTF8Encoding  encoding=new System.Text.UTF8Encoding();
   return encoding.GetBytes(str);
}

byte[] strToByteArray(string str)
{
    System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
    return enc.GetBytes(str);
}

Sie können den folgenden Code für die Konvertierung zwischen Zeichenfolge und Byte-Array verwenden.

string s = "Hello World";

// String to Byte[]

byte[] byte1 = System.Text.Encoding.Default.GetBytes(s);

// OR

byte[] byte2 = System.Text.ASCIIEncoding.Default.GetBytes(s);

// Byte[] to string

string str = System.Text.Encoding.UTF8.GetString(byte1);

Mit dem Aufkommen der Span<T>Veröffentlichung mit C # 7.2 lautet die kanonische Technik zum Erfassen der zugrunde liegenden Speicherdarstellung eines Strings in einem verwalteten Byte-Array:

byte[] bytes = "rubbish_\u9999_string".AsSpan().AsBytes().ToArray();

Das Zurückkonvertieren sollte kein Starter sein, da dies bedeutet, dass Sie die Daten tatsächlich irgendwie interpretieren, aber der Vollständigkeit halber:

string s;
unsafe
{
    fixed (char* f = &bytes.AsSpan().NonPortableCast<byte, char>().DangerousGetPinnableReference())
    {
        s = new string(f);
    }
}

Die Namen NonPortableCastund DangerousGetPinnableReferencesollten das Argument fördern, dass Sie dies wahrscheinlich nicht tun sollten.

Beachten Sie, dass für die Arbeit mit Span<T>das System.Memory NuGet-Paket installiert werden muss .

Unabhängig davon implizieren die eigentliche ursprüngliche Frage und die nachfolgenden Kommentare, dass der zugrunde liegende Speicher nicht "interpretiert" wird (was meiner Meinung nach bedeutet, dass das Mittel nicht geändert oder gelesen wird, ohne dass es so geschrieben werden muss, wie es ist), was auf eine gewisse Implementierung der StreamKlasse hinweist sollte verwendet werden, anstatt über die Daten als Zeichenfolgen nachzudenken.

Ich bin nicht sicher, aber ich denke, der String speichert seine Informationen als Array von Zeichen, was mit Bytes ineffizient ist. Insbesondere lautet die Definition eines Zeichens "Repräsentiert ein Unicode-Zeichen".

Nehmen Sie dieses Beispielbeispiel:

String str = "asdf éß";
String str2 = "asdf gh";
EncodingInfo[] info =  Encoding.GetEncodings();
foreach (EncodingInfo enc in info)
{
    System.Console.WriteLine(enc.Name + " - " 
      + enc.GetEncoding().GetByteCount(str)
      + enc.GetEncoding().GetByteCount(str2));
}

Beachten Sie, dass die Unicode-Antwort in beiden Fällen 14 Byte beträgt, während die UTF-8-Antwort für die erste nur 9 Byte und für die zweite nur 7 Byte beträgt.

Wenn Sie also nur die von der Zeichenfolge verwendeten Bytes möchten, verwenden Sie einfach Encoding.Unicode, aber der Speicherplatz ist ineffizient.

Das Hauptproblem besteht darin, dass eine Glyphe in einer Zeichenfolge 32 Bit benötigt (16 Bit für einen Zeichencode), ein Byte jedoch nur 8 Bit übrig hat. Eine Eins-zu-Eins-Zuordnung gibt es nur, wenn Sie sich auf Zeichenfolgen beschränken, die nur ASCII-Zeichen enthalten. System.Text.Encoding bietet viele Möglichkeiten, eine Zeichenfolge Byte [] zuzuordnen. Sie müssen eine auswählen, die Informationsverlust vermeidet und von Ihrem Client einfach verwendet werden kann, wenn er das Byte [] wieder einer Zeichenfolge zuordnen muss .

Utf8 ist eine beliebte Codierung, kompakt und nicht verlustbehaftet.

Verwenden:

    string text = "string";
    byte[] array = System.Text.Encoding.UTF8.GetBytes(text);

Das Ergebnis ist:

[0] = 115
[1] = 116
[2] = 114
[3] = 105
[4] = 110
[5] = 103

Schnellste Weg

public static byte[] GetBytes(string text)
{
    return System.Text.ASCIIEncoding.UTF8.GetBytes(text);
}

EDIT als Makotosan kommentierte dies ist jetzt die beste Art und Weise:

Encoding.UTF8.GetBytes(text)

Wie konvertiere ich eine Zeichenfolge in .NET (C #) in ein Byte [], ohne manuell eine bestimmte Codierung anzugeben?

Eine Zeichenfolge in .NET stellt Text als Folge von UTF-16-Codeeinheiten dar, sodass die Bytes bereits in UTF-16 im Speicher codiert sind.

Mehrdads Antwort

Sie können Mehrdads Antwort verwenden , aber es wird tatsächlich eine Codierung verwendet, da die Zeichen UTF-16 sind. Es ruft ToCharArray auf, das beim Betrachten der Quelle ein erstellt char[]und den Speicher direkt darauf kopiert. Anschließend werden die Daten in ein Byte-Array kopiert, das ebenfalls zugewiesen ist. Unter der Haube werden also die zugrunde liegenden Bytes zweimal kopiert und ein char-Array zugewiesen, das nach dem Aufruf nicht verwendet wird.

Tom Blodgets Antwort

Die Antwort von Tom Blodget ist 20 bis 30% schneller als die von Mehrdad, da der Zwischenschritt des Zuweisens eines char-Arrays und des Kopierens der Bytes übersprungen wird. Sie müssen jedoch mit der /unsafeOption kompilieren . Wenn Sie absolut keine Codierung verwenden möchten, ist dies meiner Meinung nach der richtige Weg. Wenn Sie Ihr Verschlüsselungs-Login in den fixedBlock einfügen, müssen Sie nicht einmal ein separates Byte-Array zuweisen und die Bytes darauf kopieren.

Warum sollte auch die Kodierung berücksichtigt werden? Kann ich nicht einfach abrufen, in welchen Bytes die Zeichenfolge gespeichert wurde? Warum besteht eine Abhängigkeit von Zeichenkodierungen?

Weil das der richtige Weg ist. stringist eine Abstraktion.

Die Verwendung einer Codierung kann zu Problemen führen, wenn Sie Zeichenfolgen mit ungültigen Zeichen haben. Dies sollte jedoch nicht passieren. Wenn Sie Daten mit ungültigen Zeichen in Ihre Zeichenfolge aufnehmen, machen Sie es falsch. Sie sollten wahrscheinlich zunächst ein Byte-Array oder eine Base64-Codierung verwenden.

Wenn Sie verwenden System.Text.Encoding.Unicode, ist Ihr Code widerstandsfähiger. Sie müssen sich keine Sorgen um die Endianness machen des Systems machen, auf dem Ihr Code ausgeführt wird. Sie müssen sich keine Sorgen machen, wenn die nächste Version der CLR eine andere interne Zeichenkodierung verwendet.

Ich denke, die Frage ist nicht, warum Sie sich um die Codierung kümmern möchten, sondern warum Sie sie ignorieren und etwas anderes verwenden möchten. Die Codierung soll die Abstraktion einer Zeichenfolge in einer Folge von Bytes darstellen. System.Text.Encoding.UnicodeSie erhalten eine kleine Codierung der Endian-Byte-Reihenfolge und können dies jetzt und in Zukunft auf jedem System tun.

Der Ansatz, der dem OP am nächsten kommt, ist der von Tom Blodget, der tatsächlich in das Objekt geht und die Bytes extrahiert. Ich sage am nächsten, weil es von der Implementierung des String-Objekts abhängt.

"Can't I simply get what bytes the string has been stored in?"

Sicher, aber hier entsteht der grundlegende Fehler in der Frage. Der String ist ein Objekt, das eine interessante Datenstruktur haben könnte. Wir wissen es bereits, weil es ermöglicht, ungepaarte Surrogate zu speichern. Es könnte die Länge speichern. Es könnte einen Zeiger auf jeden der 'gepaarten' Surrogate behalten, was ein schnelles Zählen ermöglicht. Alle diese zusätzlichen Bytes sind nicht Teil der Zeichendaten.

Was Sie wollen, sind die Bytes jedes Zeichens in einem Array. Und hier kommt die 'Codierung' ins Spiel. Standardmäßig erhalten Sie UTF-16LE. Wenn Sie sich nicht für die Bytes selbst interessieren, außer für den Roundtrip, können Sie eine beliebige Codierung einschließlich der 'Standardcodierung' auswählen und später wieder konvertieren (unter der Annahme derselben Parameter wie Standardcodierung, Codepunkte und Fehlerkorrekturen) , Dinge erlaubt wie ungepaarte Leihmütter, etc.

Aber warum sollte man die "Kodierung" der Magie überlassen? Warum nicht die Codierung angeben, damit Sie wissen, welche Bytes Sie erhalten werden?

"Why is there a dependency on character encodings?"

Codierung (in diesem Zusammenhang) bedeutet einfach die Bytes, die Ihre Zeichenfolge darstellen. Nicht die Bytes des String-Objekts. Sie wollten die Bytes, in denen die Zeichenfolge gespeichert wurde - hier wurde die Frage naiv gestellt. Sie wollten die Zeichenfolgenbytes in einem zusammenhängenden Array, das die Zeichenfolge darstellt, und nicht alle anderen Binärdaten, die ein Zeichenfolgenobjekt enthalten kann.

Was bedeutet, wie eine Zeichenfolge gespeichert wird, ist irrelevant. Sie möchten eine Zeichenfolge, die in Bytes in einem Byte-Array "codiert" ist.

Ich mag die Antwort von Tom Bloget, weil er Sie in Richtung "Bytes des String-Objekts" geführt hat. Es hängt jedoch von der Implementierung ab, und da er sich Interna ansieht, kann es schwierig sein, eine Kopie der Zeichenfolge wiederherzustellen.

Mehrdads Antwort ist falsch, weil sie auf konzeptioneller Ebene irreführend ist. Sie haben noch eine Liste von codierten Bytes. Seine spezielle Lösung ermöglicht es, ungepaarte Surrogate zu erhalten - dies ist implementierungsabhängig. Seine spezielle Lösung würde die Bytes der Zeichenfolge nicht genau erzeugen, wenn GetBytesdie Zeichenfolge standardmäßig in UTF-8 zurückgegeben würde.

Ich habe meine Meinung dazu geändert (Mehrdads Lösung) - dies bekommt nicht die Bytes der Zeichenfolge; Vielmehr werden die Bytes des Zeichenarrays abgerufen, das aus der Zeichenfolge erstellt wurde. Unabhängig von der Codierung hat der Datentyp char in c # eine feste Größe. Dies ermöglicht die Erzeugung eines Byte-Arrays mit konsistenter Länge und die Wiedergabe des Zeichen-Arrays basierend auf der Größe des Byte-Arrays. Wenn also die Codierung UTF-8 wäre, aber jedes Zeichen 6 Byte groß wäre, um den größten utf8-Wert aufzunehmen, würde es immer noch funktionieren. In der Tat spielt die Kodierung des Zeichens keine Rolle.

Es wurde jedoch eine Konvertierung verwendet - jedes Zeichen wurde in ein Feld mit fester Größe (Zeichentyp von c #) eingefügt. Was diese Darstellung ist, spielt jedoch keine Rolle, was technisch die Antwort auf das OP ist. Also - wenn Sie trotzdem konvertieren wollen ... Warum nicht "codieren"?

Sie können den folgenden Code verwenden, um stringa byte arrayin .NET zu konvertieren

string s_unicode = "abcéabc";
byte[] utf8Bytes = System.Text.Encoding.UTF8.GetBytes(s_unicode);

Wenn Sie wirklich eine Kopie der zugrunde liegenden Bytes einer Zeichenfolge möchten, können Sie eine Funktion wie die folgende verwenden. Sie sollten jedoch nicht weiterlesen, um herauszufinden, warum.

[DllImport(
        "msvcrt.dll",
        EntryPoint = "memcpy",
        CallingConvention = CallingConvention.Cdecl,
        SetLastError = false)]
private static extern unsafe void* UnsafeMemoryCopy(
    void* destination,
    void* source,
    uint count);

public static byte[] GetUnderlyingBytes(string source)
{
    var length = source.Length * sizeof(char);
    var result = new byte[length];
    unsafe
    {
        fixed (char* firstSourceChar = source)
        fixed (byte* firstDestination = result)
        {
            var firstSource = (byte*)firstSourceChar;
            UnsafeMemoryCopy(
                firstDestination,
                firstSource,
                (uint)length);
        }
    }

    return result;
}

Mit dieser Funktion erhalten Sie ziemlich schnell eine Kopie der Bytes, die Ihrer Zeichenfolge zugrunde liegen. Sie erhalten diese Bytes auf jede Art und Weise, die sie auf Ihrem System codieren. Diese Codierung ist mit ziemlicher Sicherheit UTF-16LE, aber das ist ein Implementierungsdetail, um das Sie sich nicht kümmern sollten.

Es wäre sicherer, einfacher und zuverlässiger , einfach anzurufen.

System.Text.Encoding.Unicode.GetBytes()

Höchstwahrscheinlich führt dies zum gleichen Ergebnis, ist einfacher zu tippen und die Bytes werden immer mit einem Aufruf an umgeschaltet

System.Text.Encoding.Unicode.GetString()

Hier ist meine unsichere Umsetzung Stringzu Byte[]konvertieren:

public static unsafe Byte[] GetBytes(String s)
{
    Int32 length = s.Length * sizeof(Char);
    Byte[] bytes = new Byte[length];

    fixed (Char* pInput = s)
    fixed (Byte* pBytes = bytes)
    {
        Byte* source = (Byte*)pInput;
        Byte* destination = pBytes;

        if (length >= 16)
        {
            do
            {
                *((Int64*)destination) = *((Int64*)source);
                *((Int64*)(destination + 8)) = *((Int64*)(source + 8));

                source += 16;
                destination += 16;
            }
            while ((length -= 16) >= 16);
        }

        if (length > 0)
        {
            if ((length & 8) != 0)
            {
                *((Int64*)destination) = *((Int64*)source);

                source += 8;
                destination += 8;
            }

            if ((length & 4) != 0)
            {
                *((Int32*)destination) = *((Int32*)source);

                source += 4;
                destination += 4;
            }

            if ((length & 2) != 0)
            {
                *((Int16*)destination) = *((Int16*)source);

                source += 2;
                destination += 2;
            }

            if ((length & 1) != 0)
            {
                ++source;
                ++destination;

                destination[0] = source[0];
            }
        }
    }

    return bytes;
}

Es ist viel schneller als das der akzeptierten Antwort, auch wenn es nicht so elegant ist wie es ist. Hier sind meine Stoppuhr-Benchmarks über 10000000 Iterationen:

[Second String: Length 20]
Buffer.BlockCopy: 746ms
Unsafe: 557ms

[Second String: Length 50]
Buffer.BlockCopy: 861ms
Unsafe: 753ms

[Third String: Length 100]
Buffer.BlockCopy: 1250ms
Unsafe: 1063ms

Um es zu verwenden, müssen Sie in Ihren Projekterstellungseigenschaften "Unsicheren Code zulassen" ankreuzen. Gemäß .NET Framework 3.5 kann diese Methode auch als Zeichenfolgenerweiterung verwendet werden:

public static unsafe class StringExtensions
{
    public static Byte[] ToByteArray(this String s)
    {
        // Method Code
    }
}

Verwenden Sie einfach dies:

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

Die Zeichenfolge kann aus folgenden Gründen auf verschiedene Weise in ein Byte-Array konvertiert werden: .NET unterstützt Unicode, und Unicode standardisiert mehrere Differenzcodierungen, die als UTFs bezeichnet werden. Sie haben unterschiedliche Längen der Bytedarstellung, sind jedoch in dem Sinne äquivalent, dass eine Zeichenfolge, wenn sie codiert wird, zurück in die Zeichenfolge codiert werden kann. Wenn die Zeichenfolge jedoch mit einer UTF codiert und unter der Annahme einer anderen UTF decodiert wird, wenn sie geschraubt werden kann oben.

Außerdem unterstützt .NET Nicht-Unicode-Codierungen, diese sind jedoch im Allgemeinen nicht gültig (nur gültig, wenn eine begrenzte Teilmenge des Unicode-Codepunkts in einer tatsächlichen Zeichenfolge wie ASCII verwendet wird). Intern unterstützt .NET UTF-16, für die Stream-Darstellung wird jedoch normalerweise UTF-8 verwendet. Es ist auch ein Standard für das Internet.

Es überrascht nicht, dass die Serialisierung von Zeichenfolgen in ein Array von Bytes und die Deserialisierung von der Klasse unterstützt wird System.Text.Encoding, die eine abstrakte Klasse ist. Die abgeleiteten Klassen unterstützen konkrete Codierungen: ASCIIEncodingund vier UTFs ( System.Text.UnicodeEncodingunterstützt UTF-16)

Ref diesen Link.

Zur Serialisierung in ein Array von Bytes mit System.Text.Encoding.GetBytes. Für die inverse Operation verwenden System.Text.Encoding.GetChars. Diese Funktion gibt ein Array von Zeichen zurück. Um eine Zeichenfolge abzurufen, verwenden Sie einen Zeichenfolgenkonstruktor System.String(char[]).
Ref diese Seite.

Beispiel:

string myString = //... some string

System.Text.Encoding encoding = System.Text.Encoding.UTF8; //or some other, but prefer some UTF is Unicode is used
byte[] bytes = encoding.GetBytes(myString);

//next lines are written in response to a follow-up questions:

myString = new string(encoding.GetChars(bytes));
byte[] bytes = encoding.GetBytes(myString);
myString = new string(encoding.GetChars(bytes));
byte[] bytes = encoding.GetBytes(myString);

//how many times shall I repeat it to show there is a round-trip? :-)

Es hängt davon ab, was Sie die Bytes für wollen

Dies liegt daran, wie Tyler so treffend sagte : "Strings sind keine reinen Daten. Sie haben auch Informationen ." In diesem Fall handelt es sich bei den Informationen um eine Codierung, die beim Erstellen der Zeichenfolge angenommen wurde.

Angenommen, Sie haben Binärdaten (anstelle von Text) in einer Zeichenfolge gespeichert

Dies basiert auf dem Kommentar von OP zu seiner eigenen Frage und ist die richtige Frage, wenn ich die Hinweise von OP auf den Anwendungsfall verstehe.

Das Speichern von Binärdaten in Strings ist aufgrund der oben erwähnten angenommenen Codierung wahrscheinlich der falsche Ansatz! Welches Programm oder welche Bibliothek diese Binärdaten in einem string(anstelle eines byte[]besser geeigneten Arrays) gespeichert hat, hat den Kampf bereits verloren, bevor er begonnen hat. Wenn sie die Bytes in einer REST-Anfrage / Antwort oder irgendetwas, das Zeichenfolgen übertragen muss, an Sie senden, wäre Base64 der richtige Ansatz.

Wenn Sie eine Textzeichenfolge mit einer unbekannten Codierung haben

Alle anderen haben diese falsche Frage falsch beantwortet.

Wenn die Zeichenfolge so wie sie ist gut aussieht, wählen Sie einfach eine Codierung aus (vorzugsweise eine, die mit UTF beginnt), verwenden Sie die entsprechende System.Text.Encoding.???.GetBytes()Funktion und teilen Sie mit, wem Sie die Bytes für die ausgewählte Codierung geben.

Auf die Frage, was Sie mit den Bytes machen wollen, antworteten Sie :

Ich werde es verschlüsseln. Ich kann es verschlüsseln, ohne es zu konvertieren, aber ich möchte trotzdem wissen, warum hier die Codierung zum Tragen kommt. Gib mir einfach die Bytes, sage ich.

Unabhängig davon, ob Sie diese verschlüsselten Daten über das Netzwerk senden, später wieder in den Speicher laden oder auf einen anderen Prozess übertragen möchten, beabsichtigen Sie eindeutig, sie irgendwann zu entschlüsseln . In diesem Fall lautet die Antwort, dass Sie ein Kommunikationsprotokoll definieren. Ein Kommunikationsprotokoll sollte nicht definiert in Bezug auf den Details der Implementierung Ihrer Programmiersprache und die damit verbundene Laufzeit. Dafür gibt es mehrere Gründe:

• Möglicherweise müssen Sie mit einem Prozess kommunizieren, der in einer anderen Sprache oder Laufzeit implementiert ist. (Dies kann beispielsweise einen Server umfassen, der auf einem anderen Computer ausgeführt wird oder die Zeichenfolge an einen JavaScript-Browser-Client sendet.)
• Das Programm wird möglicherweise in Zukunft in einer anderen Sprache oder Laufzeit erneut implementiert.
• Die .NET-Implementierung kann die interne Darstellung von Zeichenfolgen ändern. Sie mögen denken, dass dies weit hergeholt klingt, aber dies geschah tatsächlich in Java 9 , um die Speichernutzung zu reduzieren. Es gibt keinen Grund, warum .NET diesem Beispiel nicht folgen könnte. Skeet schlägt vor, dass UTF-16 heute wahrscheinlich nicht optimal ist, was dazu führt, dass das Emoji und andere Unicode-Blöcke ebenfalls mehr als 2 Bytes zur Darstellung benötigen, was die Wahrscheinlichkeit erhöht, dass sich die interne Darstellung in Zukunft ändern könnte.

Für die Kommunikation (entweder mit einem völlig unterschiedlichen Prozess oder mit demselben Programm in der Zukunft) müssen Sie Ihr Protokoll streng definieren, um die Schwierigkeit zu minimieren, damit zu arbeiten oder versehentlich Fehler zu verursachen. Abhängig von der internen Darstellung von .NET ist dies keine strikte, klare oder sogar garantiert konsistente Definition. Eine Standardkodierung ist eine strenge Definition, die Sie in Zukunft nicht enttäuschen wird.

Mit anderen Worten, Sie können Ihre Anforderungen an die Konsistenz nicht erfüllen, ohne eine Codierung anzugeben.

Sie können sich sicherlich für die direkte Verwendung von UTF-16 entscheiden, wenn Sie feststellen, dass Ihr Prozess eine erheblich bessere Leistung erbringt, da .NET ihn intern oder aus einem anderen Grund verwendet. Sie müssen diese Codierung jedoch explizit auswählen und diese Konvertierungen explizit in Ihrem Code durchführen, anstatt davon abhängig zu sein zur internen Implementierung von .NET.

Wählen Sie also eine Codierung und verwenden Sie sie:

using System.Text;

// ...

Encoding.Unicode.GetBytes("abc"); # UTF-16 little endian
Encoding.UTF8.GetBytes("abc")

Wie Sie sehen können, ist es auch weniger Code, nur die integrierten Codierungsobjekte zu verwenden, als Ihre eigenen Lese- / Schreibmethoden zu implementieren.

Zwei Wege:

public static byte[] StrToByteArray(this string s)
{
    List<byte> value = new List<byte>();
    foreach (char c in s.ToCharArray())
        value.Add(c.ToByte());
    return value.ToArray();
}

Und,

public static byte[] StrToByteArray(this string s)
{
    s = s.Replace(" ", string.Empty);
    byte[] buffer = new byte[s.Length / 2];
    for (int i = 0; i < s.Length; i += 2)
        buffer[i / 2] = (byte)Convert.ToByte(s.Substring(i, 2), 16);
    return buffer;
}

Ich neige dazu, die untere öfter als die obere zu verwenden, habe sie nicht auf Geschwindigkeit gemessen.

bytes[] buffer = UnicodeEncoding.UTF8.GetBytes(string something); //for converting to UTF then get its bytes

bytes[] buffer = ASCIIEncoding.ASCII.GetBytes(string something); //for converting to ascii then get its bytes