Come posso convertire a stringin byte[]in .NET (C #) senza specificare manualmente una codifica specifica?

Ho intenzione di crittografare la stringa. Posso crittografarlo senza convertirlo, ma mi piacerebbe comunque sapere perché la codifica viene riprodotta qui.

Inoltre, perché la codifica dovrebbe essere presa in considerazione? Non posso semplicemente ottenere in quali byte è stata memorizzata la stringa? Perché esiste una dipendenza dalle codifiche dei caratteri?

Contrariamente alle risposte qui, NON devi preoccuparti della codifica se i byte non devono essere interpretati!

Come hai già detto, il tuo obiettivo è, semplicemente, "ottenere in quali byte è stata memorizzata la stringa" .
(E, naturalmente, per essere in grado di ricostruire la stringa dai byte.)

Per quegli obiettivi, sinceramente non capisco perché le persone continuino a dirti che hai bisogno delle codifiche. Non devi certo preoccuparti delle codifiche per questo.

Basta fare questo invece:

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

Finché il tuo programma (o altri programmi) non cerca di interpretare i byte in qualche modo, cosa che ovviamente non hai menzionato che intendi fare, allora non c'è niente di sbagliato in questo approccio! Preoccuparsi delle codifiche rende la vita più complicata senza una vera ragione.

Ulteriori vantaggi di questo approccio:

Non importa se la stringa contiene caratteri non validi, perché puoi comunque ottenere i dati e ricostruire la stringa originale!

Sarà codificato e decodificato allo stesso modo, perché stai solo guardando i byte .

Se hai utilizzato una codifica specifica, tuttavia, ciò avrebbe causato problemi con la codifica / decodifica di caratteri non validi.

Dipende dalla codifica della stringa ( ASCII , UTF-8 , ...).

Per esempio:

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

Un piccolo esempio del perché la codifica è importante:

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 semplicemente non è attrezzato per gestire caratteri speciali.

Internamente, il framework .NET utilizza UTF-16 per rappresentare le stringhe, quindi se si desidera semplicemente ottenere i byte esatti utilizzati da .NET, utilizzare System.Text.Encoding.Unicode.GetBytes (...).

Vedere Codifica dei caratteri in .NET Framework (MSDN) per ulteriori informazioni.

La risposta accettata è molto, molto complicata. Utilizzare le classi .NET incluse per questo:

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

Non reinventare la ruota se non devi ...

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

È necessario tenere conto della codifica, poiché 1 carattere potrebbe essere rappresentato da 1 o più byte (fino a circa 6) e codifiche diverse tratteranno questi byte in modo diverso.

Joel ha pubblicato un post su questo:

Il minimo assoluto Ogni sviluppatore di software deve assolutamente conoscere positivamente gli Unicode e i set di caratteri (senza scuse!)

Questa è una domanda popolare È importante capire cosa si pone l'autore della domanda e che è diverso da quello che è probabilmente il bisogno più comune. Per scoraggiare l'uso improprio del codice laddove non è necessario, ho risposto prima in un secondo momento.

Esigenza comune

Ogni stringa ha un set di caratteri e una codifica. Quando converti un System.Stringoggetto in un array, System.Bytehai ancora un set di caratteri e una codifica. Per la maggior parte degli utilizzi, sapresti quale set di caratteri e codifica hai bisogno e .NET semplifica la "copia con conversione". Basta scegliere la Encodingclasse appropriata .

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

La conversione potrebbe dover gestire i casi in cui il set di caratteri di destinazione o la codifica non supportano un carattere che si trova nella fonte. Hai alcune scelte: eccezione, sostituzione o salto. La politica di default è sostituire un '?'.

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

Chiaramente, le conversioni non sono necessariamente senza perdita!

Nota: per System.Stringil set di caratteri di origine è Unicode.

L'unica cosa confusa è che .NET utilizza il nome di un set di caratteri per il nome di una particolare codifica di quel set di caratteri. Encoding.Unicodedovrebbe essere chiamato Encoding.UTF16.

Questo è tutto per la maggior parte degli usi. Se è quello che ti serve, smetti di leggere qui. Vedi il divertente articolo di Joel Spolsky se non capisci cos'è una codifica.

Bisogno specifico

Ora, l'autore della domanda chiede: "Ogni stringa è memorizzata come una matrice di byte, giusto? Perché non posso semplicemente avere quei byte?"

Non vuole alcuna conversione.

Dalle specifiche C # :

L'elaborazione di caratteri e stringhe in C # utilizza la codifica Unicode. Il tipo di carattere rappresenta un'unità di codice UTF-16 e il tipo di stringa rappresenta una sequenza di unità di codice UTF-16.

Quindi, sappiamo che se chiediamo la conversione nulla (cioè da UTF-16 a UTF-16), otterremo il risultato desiderato:

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

Ma per evitare la menzione delle codifiche, dobbiamo farlo in un altro modo. Se un tipo di dati intermedio è accettabile, esiste un collegamento concettuale per questo:

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

Questo non ci fornisce il tipo di dati desiderato, ma la risposta di Mehrdad mostra come convertire questo array Char in un array Byte usando BlockCopy . Tuttavia, questo copia la stringa due volte! E usa troppo esplicitamente il codice specifico della codifica: il tipo di dati System.Char.

L'unico modo per raggiungere i byte effettivi in ​​cui è memorizzata la stringa è utilizzare un puntatore. L' fixedistruzione consente di prendere l'indirizzo dei valori. Dalle specifiche C #:

[Per] un'espressione di tipo stringa, ... l'inizializzatore calcola l'indirizzo del primo carattere nella stringa.

Per fare ciò, il compilatore scrive il salto del codice sulle altre parti dell'oggetto stringa con RuntimeHelpers.OffsetToStringData. Quindi, per ottenere i byte non elaborati, basta creare un puntatore alla stringa e copiare il numero di byte necessari.

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

Come sottolineato da @CodesInChaos, il risultato dipende dall'endianità della macchina. Ma l'autore della domanda non si preoccupa di questo.

La prima parte della tua domanda (come ottenere i byte) ha già ricevuto risposta da altri: cerca nello System.Text.Encodingspazio dei nomi.

Risponderò alla tua domanda di follow-up: perché devi scegliere una codifica? Perché non puoi ottenerlo dalla stessa classe di stringhe?

La risposta è in due parti.

Prima di tutto, i byte usati internamente dalla classe stringa non contano , e ogni volta che si presume che lo facciano probabilmente stai introducendo un bug.

Se il tuo programma è interamente all'interno del mondo .Net, non devi preoccuparti di ottenere array di byte per le stringhe, anche se stai inviando dati attraverso una rete. Utilizzare invece .Net Serialization per preoccuparsi della trasmissione dei dati. Non ti preoccupare più dei byte effettivi: il formatter di serializzazione lo fa per te.

D'altra parte, cosa succede se si stanno inviando questi byte da qualche parte che non è possibile garantire che attireranno i dati da un flusso serializzato .Net? In questo caso devi assolutamente preoccuparti della codifica, perché ovviamente questo sistema esterno se ne frega. Quindi, di nuovo, i byte interni usati dalla stringa non contano: devi scegliere una codifica in modo da poter essere esplicito su questa codifica sul lato ricevente, anche se è la stessa codifica utilizzata internamente da .Net.

Capisco che in questo caso potresti preferire utilizzare i byte effettivi memorizzati dalla variabile stringa nella memoria, ove possibile, con l'idea che potrebbe salvare un po 'di lavoro creando il tuo flusso di byte. Tuttavia, te lo dico, non è solo importante rispetto ad assicurarsi che il tuo output sia compreso dall'altra parte e per garantire che tu debba essere esplicito con la tua codifica. Inoltre, se vuoi davvero abbinare i tuoi byte interni, puoi già semplicemente scegliere la Unicodecodifica e ottenere quel risparmio di prestazioni.

Il che mi porta alla seconda parte ... scegliere la Unicodecodifica sta dicendo a .Net di usare i byte sottostanti. Devi scegliere questa codifica, perché quando esce un nuovo Unicode-Plus, il runtime .Net deve essere libero di usare questo nuovo modello di codifica migliore senza interrompere il tuo programma. Ma, per il momento (e il futuro prevedibile), solo scegliendo la codifica Unicode ti dà quello che vuoi.

È anche importante capire che la stringa deve essere riscritta su wire e ciò comporta almeno una traduzione del bit-pattern anche quando si utilizza una codifica corrispondente . Il computer deve tenere conto di cose come Big vs Little Endian, ordine dei byte di rete, pacchetti, informazioni sulla sessione, ecc.

Giusto per dimostrare che il suono di Mehrdrad risposta opere, il suo approccio può anche persistono i caratteri surrogati spaiati (di cui molti avevano mosse contro la mia risposta, ma di cui tutti sono ugualmente colpevoli di, ad esempio System.Text.Encoding.UTF8.GetBytes, System.Text.Encoding.Unicode.GetBytes; quei metodi di codifica non possono persistere il surrogato alto caratteri d800per esempio, e quelli semplicemente sostituiscono caratteri surrogati alti con valore 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);
    }        
}

Produzione:

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

Prova con System.Text.Encoding.UTF8.GetBytes o System.Text.Encoding.Unicode.GetBytes , sostituiranno semplicemente i caratteri surrogati elevati con valore fffd

Ogni volta che c'è un movimento in questa domanda, sto ancora pensando a un serializzatore (che sia di Microsoft o di componenti di terze parti) che può persistere nelle stringhe anche se contiene caratteri surrogati spaiati; Ogni tanto google questo: serializzazione non surrogata del personaggio surrogato .NET . Questo non mi fa perdere il sonno, ma è un po 'fastidioso quando ogni tanto qualcuno commenta la mia risposta che è difettosa, eppure le loro risposte sono ugualmente difettose quando si tratta di personaggi surrogati spaiati.

Accidenti, Microsoft avrebbe dovuto usare solo il System.Buffer.BlockCopysuo BinaryFormatterツ

谢谢!

Prova questo, molto meno codice:

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

Bene, ho letto tutte le risposte e riguardavano l'uso della codifica o uno sulla serializzazione che elimina surrogati spaiati.

È negativo quando la stringa, ad esempio, proviene da SQL Server, dove è stata creata da un array di byte che archivia, ad esempio, un hash della password. Se ne eliminiamo qualcosa, memorizzerà un hash non valido e se vogliamo memorizzarlo in XML, vogliamo lasciarlo intatto (perché il writer XML rilascia un'eccezione su qualsiasi surrogato spaiato che trova).

Quindi uso la codifica Base64 degli array di byte in questi casi, ma ehi, su Internet c'è solo una soluzione a questo in C #, e contiene un bug ed è solo un modo, quindi ho corretto il bug e riscritto procedura. Ecco a voi, futuri 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);
}

Inoltre, spiega perché la codifica dovrebbe essere presa in considerazione. Non posso semplicemente ottenere in quali byte è stata memorizzata la stringa? Perché questa dipendenza dalla codifica? !!!

Perché non esistono "i byte della stringa".

Una stringa (o più genericamente, un testo) è composta da caratteri: lettere, cifre e altri simboli. È tutto. I computer, tuttavia, non sanno nulla dei personaggi; possono solo gestire byte. Pertanto, se si desidera archiviare o trasmettere testo utilizzando un computer, è necessario trasformare i caratteri in byte. Come si fa a farlo? Ecco dove arrivano le codifiche sulla scena.

Una codifica non è altro che una convenzione per tradurre caratteri logici in byte fisici. La codifica più semplice e conosciuta è ASCII, ed è tutto ciò che serve se si scrive in inglese. Per altre lingue avrai bisogno di codifiche più complete, essendo uno dei sapori Unicode la scelta più sicura al giorno d'oggi.

Quindi, in breve, cercare di "ottenere i byte di una stringa senza usare le codifiche" è impossibile quanto "scrivere un testo senza usare alcuna lingua".

A proposito, consiglio vivamente a te (e chiunque altro, per questo) di leggere questo piccolo pezzo di saggezza: il minimo assoluto che ogni sviluppatore di software deve assolutamente, positivamente conoscere su Unicode e set di caratteri (senza scuse!)

C # per convertire a stringin un bytearray:

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

È possibile utilizzare il seguente codice per la conversione tra stringa e array di byte.

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

Con l'avvento del Span<T>rilascio con C # 7.2, la tecnica canonica per acquisire la rappresentazione di memoria sottostante di una stringa in un array di byte gestiti è:

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

La riconversione dovrebbe essere un non-avviamento perché ciò significa che in realtà stai interpretando i dati in qualche modo, ma per completezza:

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

I nomi NonPortableCaste DangerousGetPinnableReferencedovrebbero favorire l'argomento secondo cui probabilmente non dovresti farlo.

Si noti che per lavorare è Span<T>necessario installare il pacchetto NuGet System.Memory .

Indipendentemente da ciò, l' attuale domanda originale e i commenti di follow-up implicano che la memoria sottostante non viene "interpretata" (che presumo significhi che non viene modificata o letta oltre la necessità di scriverla così com'è), indicando che alcune implementazioni della Streamclasse dovrebbe essere usato invece di ragionare sui dati come stringhe.

Non sono sicuro, ma penso che la stringa memorizzi le sue informazioni come una matrice di caratteri, che è inefficiente con i byte. In particolare, la definizione di un carattere è "Rappresenta un carattere Unicode".

prendere questo esempio di esempio:

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

Si noti che la risposta Unicode è di 14 byte in entrambi i casi, mentre la risposta UTF-8 è di soli 9 byte per il primo e solo 7 per il secondo.

Quindi, se vuoi solo i byte usati dalla stringa, usa semplicemente Encoding.Unicode, ma sarà inefficiente con lo spazio di archiviazione.

Il problema chiave è che un glifo in una stringa richiede 32 bit (16 bit per un codice carattere) ma un byte ha solo 8 bit da risparmiare. Una mappatura individuale non esiste se non ti limiti alle stringhe che contengono solo caratteri ASCII. System.Text.Encoding ha molti modi per mappare una stringa su byte [], devi sceglierne una che eviti la perdita di informazioni e che sia facile da usare dal tuo client quando deve mappare il byte [] su una stringa .

Utf8 è una codifica popolare, è compatta e non con perdite.

Uso:

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

Il risultato è:

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

Modo più veloce

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

EDIT come ha commentato Makotosan, questo è ora il modo migliore:

Encoding.UTF8.GetBytes(text)

Come posso convertire una stringa in un byte [] in .NET (C #) senza specificare manualmente una codifica specifica?

Una stringa in .NET rappresenta il testo come una sequenza di unità di codice UTF-16, quindi i byte sono già codificati in memoria in UTF-16.

La risposta di Mehrdad

Puoi usare la risposta di Mehrdad , ma in realtà usa una codifica perché i caratteri sono UTF-16. Chiama ToCharArray che guardando l'origine crea un char[]e copia direttamente la memoria su di esso. Quindi copia i dati in un array di byte anch'esso allocato. Quindi, sotto il cofano, copia due volte i byte sottostanti e alloca un array di caratteri che non viene utilizzato dopo la chiamata.

La risposta di Tom Blodget

La risposta di Tom Blodget è del 20-30% più veloce di Mehrdad poiché salta la fase intermedia di allocazione di un array di caratteri e copia dei byte su di esso, ma richiede la compilazione con l' /unsafeopzione. Se non vuoi assolutamente usare la codifica, penso che questa sia la strada da percorrere. Se inserisci l'accesso di crittografia all'interno del fixedblocco, non è nemmeno necessario allocare un array di byte separato e copiarvi i byte.

Inoltre, perché la codifica dovrebbe essere presa in considerazione? Non posso semplicemente ottenere in quali byte è stata memorizzata la stringa? Perché esiste una dipendenza dalle codifiche dei caratteri?

Perché questo è il modo corretto di farlo. stringè un'astrazione.

L'uso di una codifica potrebbe creare problemi se hai "stringhe" con caratteri non validi, ma ciò non dovrebbe accadere. Se stai ricevendo dati nella tua stringa con caratteri non validi, stai sbagliando. Probabilmente dovresti usare una matrice di byte o una codifica Base64 per iniziare.

Se lo usi System.Text.Encoding.Unicode, il tuo codice sarà più resiliente. Non devi preoccuparti dell'endianità del sistema su cui verrà eseguito il tuo codice. Non devi preoccuparti se la prossima versione di CLR utilizzerà una codifica di caratteri interna diversa.

Penso che la domanda non sia perché vuoi preoccuparti della codifica, ma perché vuoi ignorarla e usare qualcos'altro. La codifica intende rappresentare l'astrazione di una stringa in una sequenza di byte. System.Text.Encoding.Unicodeti darà un po 'di codifica dell'ordine dei byte endian ed eseguirà lo stesso su tutti i sistemi, ora e in futuro.

L'approccio più vicino alla domanda del PO è quello di Tom Blodget, che in realtà entra nell'oggetto ed estrae i byte. Dico più vicino perché dipende dall'implementazione dell'oggetto String.

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

Certo, ma è qui che sorge l'errore fondamentale nella domanda. La stringa è un oggetto che potrebbe avere una struttura dati interessante. Sappiamo già che lo fa, perché consente di conservare surrogati non accoppiati. Potrebbe memorizzare la lunghezza. Potrebbe tenere un puntatore a ciascuno dei surrogati "accoppiati" consentendo un conteggio rapido. Ecc. Tutti questi byte extra non fanno parte dei dati dei caratteri.

Quello che vuoi sono i byte di ogni personaggio in un array. Ed è qui che entra in gioco la "codifica". Per impostazione predefinita otterrai UTF-16LE. Se non ti interessano i byte stessi ad eccezione del round trip, puoi scegliere qualsiasi codifica incluso il 'default', e riconvertirla in seguito (assumendo gli stessi parametri come quello che era la codifica predefinita, punti di codice, correzioni di bug , cose consentite come surrogati spaiati, ecc.

Ma perché lasciare la "codifica" alla magia? Perché non specificare la codifica in modo da sapere quali byte riceverai?

"Why is there a dependency on character encodings?"

La codifica (in questo contesto) significa semplicemente i byte che rappresentano la tua stringa. Non i byte dell'oggetto stringa. Volevi i byte in cui è stata memorizzata la stringa - è qui che la domanda è stata posta in modo ingenuo. Volevi i byte di stringa in un array contiguo che rappresenta la stringa e non tutti gli altri dati binari che un oggetto stringa può contenere.

Ciò significa che la memorizzazione di una stringa è irrilevante. Volete una stringa "Codificata" in byte in una matrice di byte.

Mi piace la risposta di Tom Bloget perché ti ha portato verso la direzione dei "byte dell'oggetto stringa". Tuttavia, dipende dall'implementazione e, poiché sta sbirciando all'interno, potrebbe essere difficile ricostituire una copia della stringa.

La risposta di Mehrdad è sbagliata perché fuorviante a livello concettuale. Hai ancora un elenco di byte, codificato. La sua particolare soluzione consente di preservare surrogati spaiati - questo dipende dall'implementazione. La sua soluzione particolare non produrrebbe i byte GetBytesdella stringa in modo accurato se restituisse la stringa in UTF-8 per impostazione predefinita.

Ho cambiato idea su questo (la soluzione di Mehrdad) - questo non sta ottenendo i byte della stringa; piuttosto sta ottenendo i byte della matrice di caratteri creata dalla stringa. Indipendentemente dalla codifica, il tipo di dati char in c # è una dimensione fissa. Ciò consente di produrre un array di byte di lunghezza costante e di riprodurre l'array di caratteri in base alle dimensioni dell'array di byte. Quindi, se la codifica fosse UTF-8, ma ogni carattere era di 6 byte per contenere il valore utf8 più grande, funzionerebbe comunque. Quindi davvero - la codifica del personaggio non ha importanza.

Ma è stata utilizzata una conversione: ogni personaggio è stato inserito in una casella di dimensioni fisse (tipo di carattere di c #). Tuttavia, non importa quale sia tale rappresentazione, che è tecnicamente la risposta al PO. Quindi, se hai intenzione di convertire comunque ... Perché non "codificare"?

È possibile utilizzare il seguente codice per convertire stringa byte arrayin a .NET

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

Se vuoi davvero una copia dei byte sottostanti di una stringa, puoi usare una funzione come quella che segue. Tuttavia, non dovresti continuare a leggere per scoprire perché.

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

Questa funzione ti darà una copia dei byte sottostanti la tua stringa, abbastanza rapidamente. Otterrai quei byte in qualunque modo essi stiano codificando sul tuo sistema. Questa codifica è quasi certamente UTF-16LE ma è un dettaglio di implementazione di cui non dovresti preoccuparti.

Sarebbe più sicuro, più semplice e più affidabile chiamare,

System.Text.Encoding.Unicode.GetBytes()

Con ogni probabilità questo darà lo stesso risultato, è più facile da digitare e i byte andranno sempre di andata e ritorno con una chiamata a

System.Text.Encoding.Unicode.GetString()

Ecco la mia implementazione non sicura di Stringalla Byte[]conversione:

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

È molto più veloce di quello di una persona accettata, anche se non così elegante come è. Ecco i miei benchmark Cronometro oltre 10000000 iterazioni:

[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

Per usarlo, è necessario selezionare "Consenti codice non sicuro" nelle proprietà di compilazione del progetto. Secondo .NET Framework 3.5, questo metodo può essere utilizzato anche come estensione String:

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

Basta usare questo:

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

La stringa può essere convertita in array di byte in diversi modi, a causa del seguente fatto: .NET supporta Unicode e Unicode standardizza diverse codifiche di differenza chiamate UTF. Hanno diverse lunghezze di rappresentazione dei byte ma sono equivalenti in quel senso che quando una stringa è codificata, può essere codificata nuovamente sulla stringa, ma se la stringa è codificata con un UTF e decodificata nell'ipotesi di UTF diverso se può essere avvitata su.

Inoltre, .NET supporta codifiche non Unicode, ma non sono valide in generale (saranno valide solo se un sottoinsieme limitato di punti di codice Unicode viene utilizzato in una stringa effettiva, come ASCII). Internamente, .NET supporta UTF-16, ma per la rappresentazione dello stream viene solitamente utilizzato UTF-8. È anche uno standard di fatto per Internet.

Non sorprende che la serializzazione della stringa in un array di byte e la deserializzazione siano supportate dalla classe System.Text.Encoding, che è una classe astratta; le sue classi derivate supportano codifiche concrete: ASCIIEncodinge quattro UTF (System.Text.UnicodeEncoding supporta UTF-16)

Rif questo link.

Per la serializzazione su una matrice di byte mediante System.Text.Encoding.GetBytes. Per l'operazione inversa utilizzareSystem.Text.Encoding.GetChars . Questa funzione restituisce una matrice di caratteri, quindi per ottenere una stringa, usa un costruttore di stringhe System.String(char[]).
Rif. Questa pagina.

Esempio:

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? :-)

Dipende da cosa vuoi i byte PER

Questo perché, come ha giustamente affermato Tyler , "le stringhe non sono dati puri. Hanno anche informazioni ". In questo caso, l'informazione è una codifica che è stata assunta al momento della creazione della stringa.

Supponendo che tu abbia dati binari (piuttosto che testo) memorizzati in una stringa

Questo si basa sul commento di OP sulla sua stessa domanda, ed è la domanda corretta se capisco i suggerimenti di OP sul caso d'uso.

La memorizzazione di dati binari nelle stringhe è probabilmente l'approccio sbagliato a causa della presunta codifica menzionata sopra! Qualunque programma o libreria abbia archiviato quei dati binari in un string(anziché in un byte[]array che sarebbe stato più appropriato) ha già perso la battaglia prima che iniziasse. Se ti stanno inviando i byte in una richiesta / risposta REST o in qualcosa che deve trasmettere stringhe, Base64 sarebbe l'approccio giusto.

Se hai una stringa di testo con una codifica sconosciuta

Tutti gli altri hanno risposto in modo errato a questa domanda errata.

Se la stringa sembra essere così com'è, basta scegliere una codifica (preferibilmente una che inizia con UTF), utilizzare la System.Text.Encoding.???.GetBytes()funzione corrispondente e dire a chi si danno i byte a quale codifica hai scelto.

Quando ti viene chiesto cosa intendi fare con i byte, hai risposto :

Ho intenzione di crittografarlo. Posso crittografarlo senza convertirlo, ma mi piacerebbe comunque sapere perché la codifica viene riprodotta qui. Dammi solo i byte è quello che dico.

Indipendentemente dal fatto che tu abbia intenzione di inviare questi dati crittografati sulla rete, caricarli di nuovo in memoria in un secondo momento o trasferirli a vapore in un altro processo, hai chiaramente intenzione di decrittografarli a un certo punto. In tal caso, la risposta è che stai definendo un protocollo di comunicazione. Un protocollo di comunicazione non deve essere definito in termini di dettagli di implementazione del linguaggio di programmazione e del runtime associato. Ci sono diverse ragioni per questo:

• Potrebbe essere necessario comunicare con un processo implementato in un'altra lingua o runtime. (Ciò potrebbe includere un server in esecuzione su un altro computer o l'invio della stringa a un client browser JavaScript, ad esempio.)
• Il programma potrebbe essere reimplementato in un'altra lingua o runtime in futuro.
• L'implementazione di .NET potrebbe cambiare la rappresentazione interna delle stringhe. Potresti pensare che questo sembri inverosimile, ma in realtà è successo in Java 9 per ridurre l'utilizzo della memoria. Non c'è motivo per cui .NET non possa seguirne l'esempio. Skeet suggerisce che oggi UTF-16 probabilmente non è ottimale per far emergere le emoji e altri blocchi di Unicode che richiedono oltre 2 byte per rappresentare, aumentando la probabilità che la rappresentazione interna possa cambiare in futuro.

Per comunicare (con un processo completamente diverso o con lo stesso programma in futuro), è necessario definire il protocollo in modo rigoroso per ridurre al minimo la difficoltà di lavorare con esso o di creare accidentalmente bug. A seconda della rappresentazione interna di .NET, la definizione non è rigorosa, chiara o addirittura garantita. Una codifica standard è una definizione rigorosa che non ti deluderà in futuro.

In altre parole, non puoi soddisfare i tuoi requisiti di coerenza senza specificare una codifica.

Puoi certamente scegliere di utilizzare UTF-16 direttamente se ritieni che il tuo processo funzioni in modo significativamente migliore poiché .NET lo utilizza internamente o per qualsiasi altro motivo, ma devi scegliere quella codifica in modo esplicito ed eseguire quelle conversioni in modo esplicito nel tuo codice anziché dipendere sull'implementazione interna di .NET.

Quindi scegli una codifica e usala:

using System.Text;

// ...

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

Come puoi vedere, in realtà è anche meno codice per usare solo gli oggetti di codifica incorporati che per implementare i tuoi metodi di lettura / scrittura.

Due strade:

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

E,

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

Tendo a usare quello inferiore più spesso di quello superiore, non li ho confrontati per la velocità.

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