Bagaimana cara mengonversikan stringke byte[]dalam .NET (C #) tanpa secara manual menentukan pengkodean tertentu?

Saya akan mengenkripsi string. Saya dapat mengenkripsi tanpa mengubah, tetapi saya masih ingin tahu mengapa encoding datang untuk bermain di sini.

Juga, mengapa pengkodean harus dipertimbangkan? Tidak bisakah saya mendapatkan byte apa yang telah disimpan oleh string? Mengapa ada ketergantungan pada pengkodean karakter?

Bertentangan dengan jawaban di sini, Anda TIDAK perlu khawatir tentang penyandian jika byte tidak perlu ditafsirkan!

Seperti yang Anda sebutkan, tujuan Anda adalah, sederhana, untuk "mendapatkan byte apa yang disimpan oleh string" .
(Dan, tentu saja, untuk dapat membangun kembali string dari byte.)

Untuk tujuan-tujuan itu, sejujurnya saya tidak mengerti mengapa orang-orang terus mengatakan kepada Anda bahwa Anda perlu pengkodean. Anda tentu TIDAK perlu khawatir tentang pengkodean untuk ini.

Lakukan saja ini sebagai gantinya:

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

Selama program Anda (atau program lain) tidak mencoba menafsirkan byte entah bagaimana, yang Anda jelas tidak menyebutkan Anda ingin lakukan, maka tidak ada yang salah dengan pendekatan ini! Khawatir tentang penyandian hanya membuat hidup Anda lebih rumit tanpa alasan yang nyata.

Manfaat tambahan untuk pendekatan ini:

Tidak masalah jika string berisi karakter yang tidak valid, karena Anda tetap bisa mendapatkan data dan merekonstruksi string asli!

Ini akan dikodekan dan didekodekan sama saja, karena Anda hanya melihat byte .

Jika Anda menggunakan pengodean tertentu, itu akan memberi Anda masalah dengan pengodean / decoding karakter yang tidak valid.

Itu tergantung pada pengkodean string Anda ( ASCII , UTF-8 , ...).

Sebagai contoh:

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

Contoh kecil mengapa penyandian penting:

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 sama sekali tidak dilengkapi untuk berurusan dengan karakter khusus.

Secara internal, .NET framework menggunakan UTF-16 untuk mewakili string, jadi jika Anda hanya ingin mendapatkan byte yang tepat yang digunakan .NET, gunakan System.Text.Encoding.Unicode.GetBytes (...).

Lihat Pengodean Karakter di .NET Framework (MSDN) untuk informasi lebih lanjut.

Jawaban yang diterima sangat, sangat rumit. Gunakan kelas .NET yang disertakan untuk ini:

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

Jangan menemukan kembali roda jika Anda tidak perlu ...

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

Anda perlu mempertimbangkan penyandian, karena 1 karakter dapat diwakili oleh 1 atau lebih byte (hingga sekitar 6), dan penyandian yang berbeda akan memperlakukan byte ini secara berbeda.

Joel memiliki posting tentang ini:

Minimum Mutlak Setiap Pengembang Perangkat Lunak, Sepenuhnya Pasti Harus Tahu Tentang Unicode dan Karakter (Tidak Ada Alasan!)

Ini pertanyaan populer. Penting untuk memahami apa yang ditanyakan oleh penulis pertanyaan, dan berbeda dari apa yang mungkin merupakan kebutuhan paling umum. Untuk mencegah penyalahgunaan kode yang tidak diperlukan, saya sudah jawab yang pertama.

Kebutuhan Umum

Setiap string memiliki rangkaian karakter dan pengodean. Saat Anda mengonversi System.Stringobjek ke array, System.ByteAnda masih memiliki kumpulan karakter dan pengodean. Untuk sebagian besar penggunaan, Anda akan tahu set karakter dan penyandian yang Anda butuhkan dan .NET membuatnya mudah untuk "menyalin dengan konversi." Pilih saja Encodingkelas yang sesuai .

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

Konversi mungkin perlu menangani kasus di mana karakter target yang ditetapkan atau pengodean tidak mendukung karakter yang ada di sumber. Anda memiliki beberapa pilihan: pengecualian, penggantian atau lewati. Kebijakan default adalah mengganti '?'.

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

Jelas, konversi tidak harus rugi!

Catatan: Untuk System.Stringrangkaian karakter sumber adalah Unicode.

Satu-satunya hal yang membingungkan adalah .NET menggunakan nama set karakter untuk nama satu pengkodean set karakter tertentu. Encoding.Unicodeharus dipanggil Encoding.UTF16.

Itu saja untuk sebagian besar penggunaan. Jika itu yang Anda butuhkan, berhenti membaca di sini. Lihat artikel Joel Spolsky yang menyenangkan jika Anda tidak mengerti apa itu encoding.

Kebutuhan Khusus

Sekarang, penulis pertanyaan bertanya, "Setiap string disimpan sebagai array byte, kan? Mengapa saya tidak bisa hanya memiliki byte itu?"

Dia tidak menginginkan pertobatan.

Dari spesifikasi C # :

Pemrosesan karakter dan string dalam C # menggunakan pengkodean Unicode. Tipe char mewakili unit kode UTF-16, dan tipe string mewakili urutan unit kode UTF-16.

Jadi, kita tahu bahwa jika kita meminta konversi nol (yaitu, dari UTF-16 ke UTF-16), kita akan mendapatkan hasil yang diinginkan:

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

Tetapi untuk menghindari penyebutan encoding, kita harus melakukannya dengan cara lain. Jika tipe data antara dapat diterima, ada jalan pintas konseptual untuk ini:

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

Itu tidak memberikan kita tipe data yang diinginkan tetapi jawaban Mehrdad menunjukkan bagaimana mengubah array Char ini menjadi array Byte menggunakan BlockCopy . Namun, ini menyalin string dua kali! Dan, itu juga secara eksplisit menggunakan kode khusus pengkodean: tipe data System.Char.

Satu-satunya cara untuk mendapatkan byte aktual dari String yang disimpan adalah dengan menggunakan pointer. The fixedpernyataan memungkinkan mengambil alamat nilai-nilai. Dari spesifikasi C #:

[Untuk] ekspresi tipe string, ... initializer menghitung alamat karakter pertama dalam string.

Untuk melakukannya, kompiler menulis kode lompati bagian lain dari objek string RuntimeHelpers.OffsetToStringData. Jadi, untuk mendapatkan byte mentah, buat saja pointer ke string dan salin jumlah byte yang dibutuhkan.

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

Seperti @CodesInChaos tunjukkan, hasilnya tergantung pada endianness dari mesin. Tetapi penulis pertanyaan tidak peduli dengan itu.

Bagian pertama dari pertanyaan Anda (cara mendapatkan byte) sudah dijawab oleh orang lain: lihat di System.Text.Encodingnamespace.

Saya akan menjawab pertanyaan tindak lanjut Anda: mengapa Anda perlu memilih penyandian? Mengapa Anda tidak bisa mendapatkannya dari kelas string itu sendiri?

Jawabannya ada dalam dua bagian.

Pertama-tama, byte yang digunakan secara internal oleh kelas string tidak penting , dan kapan pun Anda menganggapnya, Anda kemungkinan besar akan memperkenalkan bug.

Jika program Anda sepenuhnya dalam dunia. Net maka Anda tidak perlu khawatir tentang mendapatkan array byte untuk string sama sekali, bahkan jika Anda mengirim data melalui jaringan. Sebagai gantinya, gunakan .Net Serialisasi untuk khawatir tentang pengiriman data. Anda tidak perlu lagi khawatir tentang byte yang sebenarnya: formatter serialisasi melakukannya untuk Anda.

Di sisi lain, bagaimana jika Anda mengirim byte ini di suatu tempat yang Anda tidak dapat menjamin akan menarik data dari aliran serial .Net? Dalam hal ini Anda tentu perlu khawatir tentang pengkodean, karena jelas sistem eksternal ini peduli. Jadi sekali lagi, byte internal yang digunakan oleh string tidak masalah: Anda harus memilih pengkodean sehingga Anda dapat secara eksplisit tentang pengkodean ini pada sisi penerima, bahkan jika itu adalah pengkodean yang sama yang digunakan secara internal oleh .Net.

Saya mengerti bahwa dalam hal ini Anda mungkin lebih suka menggunakan byte aktual yang disimpan oleh variabel string dalam memori jika memungkinkan, dengan gagasan bahwa itu mungkin menghemat pekerjaan menciptakan aliran byte Anda. Namun, saya katakan kepada Anda itu tidak penting dibandingkan dengan memastikan bahwa output Anda dipahami di ujung yang lain, dan untuk menjamin bahwa Anda harus eksplisit dengan pengkodean Anda. Selain itu, jika Anda benar-benar ingin mencocokkan byte internal Anda, Anda sudah bisa memilih Unicodepengkodean, dan mendapatkan penghematan kinerja itu.

Yang membawa saya ke bagian kedua ... memilih Unicodeencoding adalah mengatakan Net menggunakan byte yang mendasari. Anda harus memilih penyandian ini, karena ketika beberapa Unicode-Plus yang baru dilipat keluar, runtime .Net harus bebas untuk menggunakan model penyandian yang lebih baru dan lebih baik ini tanpa merusak program Anda. Tapi, untuk saat ini (dan masa depan yang dapat dilihat), hanya memilih pengkodean Unicode memberi Anda apa yang Anda inginkan.

Penting juga untuk memahami string Anda harus ditulis ulang untuk ditransfer, dan itu melibatkan setidaknya beberapa terjemahan dari pola-bit bahkan ketika Anda menggunakan pengkodean yang cocok . Komputer perlu memperhitungkan hal-hal seperti Big vs Little Endian, urutan byte jaringan, paketisasi, informasi sesi, dll.

Hanya untuk menunjukkan bahwa jawaban suara Mehrdrad berfungsi, pendekatannya bahkan dapat bertahan pada karakter pengganti yang tidak berpasangan (yang banyak diratakan oleh jawaban saya, tetapi semua orang sama-sama bersalah, misalnya System.Text.Encoding.UTF8.GetBytes, System.Text.Encoding.Unicode.GetBytesmetode pengkodean itu tidak dapat bertahan sebagai pengganti tinggi. karakter d800misalnya, dan mereka hanya mengganti karakter pengganti tinggi dengan nilaifffd ):

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

Keluaran:

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

Cobalah dengan System.Text.Encoding.UTF8.GetBytes atau System.Text.Encoding.Unicode.GetBytes , mereka hanya akan mengganti karakter pengganti yang tinggi dengan nilai fffd

Setiap kali ada gerakan dalam pertanyaan ini, saya masih memikirkan serializer (baik itu dari Microsoft atau dari komponen pihak ke-3) yang dapat bertahan string bahkan mengandung karakter pengganti yang tidak berpasangan; Saya google ini setiap sekarang dan kemudian: serialisasi karakter pengganti berpasangan .NET . Ini tidak membuat saya kehilangan tidur, tetapi agak menjengkelkan ketika kadang-kadang ada seseorang yang mengomentari jawaban saya bahwa itu salah, namun jawaban mereka sama-sama cacat ketika menyangkut karakter pengganti yang tidak berpasangan.

Sial, Microsoft seharusnya baru saja menggunakan System.Buffer.BlockCopy dalam nyaBinaryFormatterツ

谢谢！

Coba ini, jauh lebih sedikit kode:

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

Yah, saya sudah membaca semua jawaban dan mereka tentang menggunakan encoding atau satu tentang serialisasi yang menjatuhkan pengganti yang tidak berpasangan.

Ini buruk ketika string, misalnya, berasal dari SQL Server mana ia dibangun dari penyimpanan byte array, misalnya, hash kata sandi. Jika kita membuang sesuatu darinya, itu akan menyimpan hash yang tidak valid, dan jika kita ingin menyimpannya dalam XML, kita ingin membiarkannya tetap utuh (karena penulis XML menjatuhkan pengecualian pada pengganti yang tidak berpasangan yang ditemukannya).

Jadi saya menggunakan Base64 encoding array byte dalam kasus seperti itu, tapi hei, di Internet hanya ada satu solusi untuk ini di C #, dan ada bug di dalamnya dan hanya satu cara, jadi saya sudah memperbaiki bug dan menulis kembali prosedur. Inilah Anda, para googler masa depan:

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

Juga tolong jelaskan mengapa pengkodean harus dipertimbangkan. Tidak bisakah saya mendapatkan byte apa yang telah disimpan oleh string? Mengapa ketergantungan ini pada pengkodean? !!!

Karena tidak ada yang namanya "byte dari string".

String (atau lebih umum, teks) terdiri dari karakter: huruf, angka, dan simbol lainnya. Itu saja. Komputer, bagaimanapun, tidak tahu apa-apa tentang karakter; mereka hanya bisa menangani byte. Oleh karena itu, jika Anda ingin menyimpan atau mengirim teks dengan menggunakan komputer, Anda perlu mengubah karakter menjadi byte. Bagaimana kamu melakukannya? Di sinilah pengkodean datang ke tempat kejadian.

Pengkodean hanyalah konvensi untuk menerjemahkan karakter logis ke byte fisik. Pengkodean yang paling sederhana dan paling dikenal adalah ASCII, dan itu semua yang Anda butuhkan jika Anda menulis dalam bahasa Inggris. Untuk bahasa lain, Anda akan membutuhkan penyandian yang lebih lengkap, karena salah satu dari Unicode ini merupakan pilihan paling aman saat ini.

Jadi, singkatnya, mencoba "mendapatkan byte dari sebuah string tanpa menggunakan penyandian" adalah tidak mungkin seperti "menulis teks tanpa menggunakan bahasa apa pun".

Ngomong-ngomong, saya sangat menyarankan Anda (dan siapa pun, dalam hal ini) untuk membaca kebijaksanaan kecil ini: Minimum Mutlak Setiap Pengembang Perangkat Lunak Sepenuhnya, Sepenuhnya Harus Tahu Tentang Unicode dan Karakter Set (Tanpa Alasan!)

C # untuk mengonversi a stringmenjadi 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);
}

Anda dapat menggunakan kode berikut untuk konversi antara array string dan 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);

Dengan munculnya Span<T>dirilis dengan C # 7.2, teknik kanonik untuk menangkap representasi memori yang mendasari string ke array byte yang dikelola adalah:

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

Mengubahnya kembali harus menjadi non-starter karena itu berarti Anda sebenarnya menafsirkan data entah bagaimana, tetapi demi kelengkapan:

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

Nama-nama NonPortableCastdan DangerousGetPinnableReferenceharus melanjutkan argumen bahwa Anda mungkin tidak boleh melakukan ini.

Perhatikan bahwa bekerja dengan Span<T>membutuhkan menginstal paket System.Memory NuGet .

Apapun, pertanyaan asli aktual dan komentar tindak lanjut menyiratkan bahwa memori yang mendasari tidak sedang "ditafsirkan" (yang saya asumsikan berarti tidak dimodifikasi atau dibaca di luar kebutuhan untuk menulis apa adanya), menunjukkan bahwa beberapa implementasi Streamkelas harus digunakan sebagai ganti alasan tentang data sebagai string sama sekali.

Saya tidak yakin, tapi saya pikir string menyimpan informasinya sebagai array Chars, yang tidak efisien dengan byte. Secara khusus, definisi Char adalah "Merupakan karakter Unicode".

ambil contoh contoh ini:

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

Perhatikan bahwa jawaban Unicode adalah 14 byte di kedua contoh, sedangkan jawaban UTF-8 hanya 9 byte untuk yang pertama, dan hanya 7 untuk yang kedua.

Jadi jika Anda hanya ingin byte yang digunakan oleh string, cukup gunakan Encoding.Unicode, tetapi akan tidak efisien dengan ruang penyimpanan.

Masalah utama adalah bahwa mesin terbang dalam string membutuhkan 32 bit (16 bit untuk kode karakter) tetapi byte hanya memiliki 8 bit untuk cadangan. Pemetaan satu-ke-satu tidak ada kecuali Anda membatasi diri pada string yang hanya berisi karakter ASCII. System.Text.Encoding memiliki banyak cara untuk memetakan string ke byte [], Anda harus memilih satu yang menghindari hilangnya informasi dan yang mudah digunakan oleh klien Anda ketika dia perlu memetakan byte [] kembali ke string. .

Utf8 adalah pengkodean yang populer, ringkas dan tidak lossy.

Menggunakan:

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

Hasilnya adalah:

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

Jalan tercepat

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

EDIT sebagai Makotosan berkomentar ini sekarang adalah cara terbaik:

Encoding.UTF8.GetBytes(text)

Bagaimana cara mengonversi string ke byte [] dalam .NET (C #) tanpa secara manual menentukan pengkodean tertentu?

Sebuah String dalam. NET mewakili teks sebagai urutan unit kode UTF-16, sehingga byte sudah dikodekan dalam memori di UTF-16.

Jawaban Mehrdad

Kamu bisa menggunakan jawaban Mehrdad , tetapi sebenarnya menggunakan pengodean karena karakternya adalah UTF-16. Itu panggilan ToCharArray yang melihat sumbernya menciptakan char[]dan menyalin memori secara langsung. Kemudian menyalin data ke array byte yang juga dialokasikan. Jadi di bawah tenda itu menyalin byte yang mendasarinya dua kali dan mengalokasikan array char yang tidak digunakan setelah panggilan.

Jawaban Tom Blodget

Jawaban Tom Blodget adalah 20-30% lebih cepat daripada Mehrdad karena melompati langkah menengah mengalokasikan array char dan menyalin byte ke dalamnya, tetapi mengharuskan Anda mengkompilasi dengan /unsafeopsi. Jika Anda benar-benar tidak ingin menggunakan pengodean, saya pikir ini adalah cara untuk pergi. Jika Anda memasukkan login enkripsi Anda di dalam fixedblok, Anda bahkan tidak perlu mengalokasikan array byte terpisah dan menyalin byte ke dalamnya.

Juga, mengapa pengkodean harus dipertimbangkan? Tidak bisakah saya mendapatkan byte apa yang telah disimpan oleh string? Mengapa ada ketergantungan pada pengkodean karakter?

Karena itulah cara yang tepat untuk melakukannya. stringadalah abstraksi.

Menggunakan penyandian dapat memberikan masalah jika Anda memiliki 'string' dengan karakter yang tidak valid, tetapi itu tidak boleh terjadi. Jika Anda memasukkan data ke string dengan karakter yang tidak valid, Anda salah melakukannya. Anda mungkin harus menggunakan array byte atau pengkodean Base64 untuk memulai.

Jika Anda menggunakan System.Text.Encoding.Unicode, kode Anda akan lebih tangguh. Anda tidak perlu khawatir tentang endianness sistem yang akan dijalankan oleh kode Anda. Anda tidak perlu khawatir jika versi CLR berikutnya akan menggunakan pengkodean karakter internal yang berbeda.

Saya pikir pertanyaannya bukan mengapa Anda ingin khawatir tentang pengkodean, tetapi mengapa Anda ingin mengabaikannya dan menggunakan sesuatu yang lain. Pengkodean dimaksudkan untuk mewakili abstraksi string dalam urutan byte. System.Text.Encoding.Unicodeakan memberikan Anda sedikit encoding urutan endian byte dan akan melakukan hal yang sama pada setiap sistem, sekarang dan di masa depan.

Pendekatan terdekat dengan pertanyaan OP adalah Tom Blodget, yang sebenarnya masuk ke objek dan mengekstrak byte. Saya katakan paling dekat karena itu tergantung pada implementasi Object String.

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

Tentu, tetapi di situlah kesalahan mendasar dalam pertanyaan muncul. String adalah objek yang dapat memiliki struktur data yang menarik. Kita sudah tahu itu, karena memungkinkan pengganti yang tidak berpasangan untuk disimpan. Mungkin menyimpan panjangnya. Mungkin menyimpan pointer ke masing-masing pengganti 'berpasangan' memungkinkan penghitungan cepat. Dll Semua byte tambahan ini bukan bagian dari data karakter.

Yang Anda inginkan adalah byte setiap karakter dalam sebuah array. Dan di situlah 'encoding' masuk. Secara default Anda akan mendapatkan UTF-16LE. Jika Anda tidak peduli dengan byte itu sendiri kecuali untuk perjalanan pulang pergi maka Anda dapat memilih pengkodean apa pun termasuk 'default', dan mengubahnya kembali nanti (dengan asumsi parameter yang sama seperti apa pengkodean default, titik kode, perbaikan bug , hal-hal yang diperbolehkan seperti pengganti yang tidak berpasangan, dll.

Tapi mengapa membiarkan 'pengkodean' menjadi sihir? Mengapa tidak menentukan pengkodean sehingga Anda tahu byte apa yang akan Anda dapatkan?

"Why is there a dependency on character encodings?"

Pengkodean (dalam konteks ini) berarti byte yang mewakili string Anda. Bukan byte dari objek string. Anda ingin byte yang disimpan oleh string - di sinilah pertanyaan itu ditanyakan secara naif. Anda menginginkan byte string dalam array yang berdekatan yang mewakili string, dan tidak semua data biner lain yang mungkin berisi objek string.

Yang berarti bagaimana string disimpan tidak relevan. Anda ingin string "Dikodekan" menjadi byte dalam array byte.

Saya suka jawaban Tom Bloget karena dia membawa Anda ke arah 'byte dari objek string'. Ini tergantung implementasi, dan karena dia mengintip internal mungkin sulit untuk menyusun kembali salinan string.

Tanggapan Mehrdad salah karena menyesatkan pada tingkat konseptual. Anda masih memiliki daftar byte, yang disandikan. Solusi khususnyanya memungkinkan pengganti yang tidak berpasangan untuk dilestarikan - ini tergantung pada implementasi. Solusi khususnya tidak akan menghasilkan byte string secara akurat jika GetBytesmengembalikan string dalam UTF-8 secara default.

Saya berubah pikiran tentang ini (solusi Mehrdad) - ini tidak mendapatkan byte dari string; melainkan mendapatkan byte dari array karakter yang dibuat dari string. Terlepas dari pengodean, char datatype di c # adalah ukuran tetap. Ini memungkinkan array byte panjang yang konsisten untuk diproduksi, dan memungkinkan array karakter direproduksi berdasarkan ukuran array byte. Jadi jika pengkodeannya adalah UTF-8, tetapi masing-masing karakter berukuran 6 byte untuk mengakomodasi nilai utf8 terbesar, itu masih akan berfungsi. Jadi memang - pengkodean karakter tidak masalah.

Tetapi konversi digunakan - setiap karakter ditempatkan ke dalam kotak ukuran tetap (tipe karakter c #). Namun, apa representasi itu tidak penting, yang secara teknis merupakan jawaban OP. Jadi - jika Anda tetap ingin mengonversi ... Kenapa tidak 'menyandikan'?

Anda dapat menggunakan kode berikut untuk mengonversi a stringmenjadi byte array.NET

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

Jika Anda benar-benar menginginkan salinan byte yang mendasari string, Anda dapat menggunakan fungsi seperti yang berikut. Namun, Anda sebaiknya tidak membaca terus untuk mengetahui alasannya.

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

Fungsi ini akan memberi Anda salinan byte yang mendasari string Anda, cukup cepat. Anda akan mendapatkan byte-byte itu dengan cara apa pun mereka meng-encode pada sistem Anda. Pengkodean ini hampir pasti UTF-16LE tetapi itu adalah detail implementasi yang tidak perlu Anda pedulikan.

Akan lebih aman, lebih sederhana dan lebih dapat diandalkan untuk hanya menelepon,

System.Text.Encoding.Unicode.GetBytes()

Kemungkinan ini akan memberikan hasil yang sama, lebih mudah untuk mengetik, dan byte akan selalu pulang pergi dengan panggilan ke

System.Text.Encoding.Unicode.GetString()

Berikut ini adalah implementasi tidak aman saya Stringuntuk Byte[]konversi:

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

Ini jauh lebih cepat daripada yang diterima, bahkan jika tidak seanggun itu. Berikut adalah tolok ukur Stopwatch saya lebih dari 10.000000 iterasi:

[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

Untuk menggunakannya, Anda harus mencentang "Izinkan Kode Tidak Aman" di properti build proyek Anda. Sesuai .NET Framework 3.5, metode ini juga dapat digunakan sebagai ekstensi String:

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

Cukup gunakan ini:

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

String dapat dikonversi ke byte array dalam beberapa cara berbeda, karena fakta berikut: .NET mendukung Unicode, dan Unicode menstandarisasi beberapa pengkodean perbedaan yang disebut UTF. Mereka memiliki panjang representasi byte yang berbeda tetapi setara dalam arti bahwa ketika string dikodekan, dapat dikodekan kembali ke string, tetapi jika string dikodekan dengan satu UTF dan didekodekan dengan asumsi UTF berbeda jika dapat dikacaukan naik.

Juga, .NET mendukung pengkodean non-Unicode, tetapi mereka tidak berlaku dalam kasus umum (akan valid hanya jika sub-set terbatas titik kode Unicode digunakan dalam string aktual, seperti ASCII). Secara internal, .NET mendukung UTF-16, tetapi untuk representasi aliran, UTF-8 biasanya digunakan. Ini juga merupakan standar-de-facto untuk Internet.

Tidak mengherankan, serialisasi string ke dalam array byte dan deserialization didukung oleh kelas System.Text.Encoding, yang merupakan kelas abstrak; kelas turunannya mendukung pengkodean konkret: ASCIIEncodingdan empat UTF ( System.Text.UnicodeEncodingmendukung UTF-16)

Ref tautan ini.

Untuk serialisasi ke array byte yang menggunakan System.Text.Encoding.GetBytes. Untuk penggunaan operasi terbalik System.Text.Encoding.GetChars. Fungsi ini mengembalikan array karakter, jadi untuk mendapatkan string, gunakan konstruktor string System.String(char[]).
Ref halaman ini.

Contoh:

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

Tergantung pada apa yang Anda inginkan untuk byte

Hal ini karena, sebagai Tyler sehingga tepat mengatakan , "Strings tidak data yang murni. Mereka juga memiliki informasi ." Dalam hal ini, informasi adalah pengkodean yang diasumsikan ketika string dibuat.

Dengan asumsi bahwa Anda memiliki data biner (bukan teks) yang disimpan dalam sebuah string

Ini didasarkan dari komentar OP pada pertanyaannya sendiri, dan merupakan pertanyaan yang tepat jika saya memahami petunjuk OP pada use-case.

Menyimpan data biner dalam string mungkin merupakan pendekatan yang salah karena asumsi pengkodean yang disebutkan di atas! Program atau pustaka apa pun yang menyimpan data biner dalam string(alih-alih byte[]array yang lebih cocok) telah kalah dalam pertarungan sebelum dimulai. Jika mereka mengirim byte kepada Anda dalam permintaan / tanggapan REST atau apa pun yang harus mengirimkan string, Base64 akan menjadi pendekatan yang tepat.

Jika Anda memiliki string teks dengan pengkodean yang tidak dikenal

Semua orang menjawab pertanyaan yang salah ini dengan tidak benar.

Jika string terlihat bagus apa adanya, pilih saja suatu pengkodean (lebih disukai yang dimulai dengan UTF), gunakan System.Text.Encoding.???.GetBytes()fungsi yang sesuai , dan beri tahu siapa pun yang Anda berikan byte pada pengodean yang Anda pilih.

Setelah ditanya apa yang ingin Anda lakukan dengan byte, Anda merespons :

Saya akan mengenkripsi itu. Saya dapat mengenkripsi tanpa mengubah tetapi saya masih ingin tahu mengapa encoding datang untuk bermain di sini. Beri saya byte adalah apa yang saya katakan.

Terlepas dari apakah Anda bermaksud mengirim data terenkripsi ini melalui jaringan, memuatnya kembali ke memori nanti, atau mengukusnya ke proses lain, Anda jelas bermaksud mendekripsi data itu di beberapa titik. Dalam hal ini, jawabannya adalah Anda mendefinisikan protokol komunikasi. Protokol komunikasi tidak boleh didefinisikan dalam hal rincian implementasi bahasa pemrograman Anda dan runtime terkait. Ada beberapa alasan untuk ini:

• Anda mungkin perlu berkomunikasi dengan proses yang diimplementasikan dalam bahasa atau runtime yang berbeda. (Ini mungkin termasuk server yang berjalan di komputer lain atau mengirim string ke klien browser JavaScript, misalnya.)
• Program ini dapat diimplementasikan kembali dalam bahasa yang berbeda atau runtime di masa depan.
• Implementasi .NET dapat mengubah representasi internal string. Anda mungkin berpikir ini terdengar tidak masuk akal, tetapi ini sebenarnya terjadi di Java 9 untuk mengurangi penggunaan memori. Tidak ada alasan .NET tidak dapat mengikutinya. Skeet menunjukkan bahwa UTF-16 mungkin tidak optimal hari ini memberikan emoji dan blok Unicode lain yang membutuhkan lebih dari 2 byte untuk mewakili juga, meningkatkan kemungkinan bahwa representasi internal dapat berubah di masa depan.

Untuk berkomunikasi (baik dengan proses yang sama sekali berbeda atau dengan program yang sama di masa mendatang), Anda perlu mendefinisikan protokol Anda secara ketat untuk meminimalkan kesulitan bekerja dengannya atau secara tidak sengaja membuat bug. Bergantung pada representasi internal .NET bukanlah definisi yang ketat, jelas, atau bahkan dijamin konsisten. Pengkodean standar adalah definisi ketat yang tidak akan mengecewakan Anda di masa mendatang.

Dengan kata lain, Anda tidak dapat memenuhi persyaratan Anda untuk konsistensi tanpa menentukan pengkodean.

Anda tentu dapat memilih untuk menggunakan UTF-16 secara langsung jika Anda menemukan bahwa proses Anda berkinerja lebih baik sejak. NET menggunakannya secara internal atau karena alasan lain, tetapi Anda harus memilih pengkodean secara eksplisit dan melakukan konversi tersebut secara eksplisit dalam kode Anda daripada tergantung pada implementasi internal .NET.

Jadi pilih pengodean dan gunakan:

using System.Text;

// ...

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

Seperti yang Anda lihat, sebenarnya juga lebih sedikit kode untuk hanya menggunakan objek enkode bawaan daripada menerapkan metode pembaca / penulis Anda sendiri.

Dua arah:

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

Dan,

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

Saya cenderung menggunakan bagian bawah lebih sering daripada bagian atas, belum membandingkan mereka untuk kecepatan.

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