Làm cách nào để chuyển đổi a stringthành byte[].NET (C #) mà không chỉ định thủ công một mã hóa cụ thể?

Tôi sẽ mã hóa chuỗi. Tôi có thể mã hóa nó mà không cần chuyển đổi, nhưng tôi vẫn muốn biết tại sao mã hóa lại xuất hiện ở đây.

Ngoài ra, tại sao mã hóa thậm chí nên được xem xét? Tôi không thể đơn giản nhận được byte nào mà chuỗi đã được lưu trữ? Tại sao có sự phụ thuộc vào mã hóa ký tự?

Trái với câu trả lời ở đây, bạn KHÔNG cần lo lắng về việc mã hóa nếu các byte không cần phải được giải thích!

Giống như bạn đã đề cập, mục tiêu của bạn chỉ đơn giản là "lấy chuỗi byte nào đã được lưu trữ" .
(Và, tất nhiên, để có thể xây dựng lại chuỗi từ các byte.)

Đối với những mục tiêu đó, tôi thực sự không hiểu tại sao mọi người cứ nói với bạn rằng bạn cần mã hóa. Bạn chắc chắn KHÔNG cần phải lo lắng về mã hóa cho việc này.

Chỉ cần làm điều này thay vào đó:

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

Miễn là chương trình của bạn (hoặc các chương trình khác) không cố gắng diễn giải các byte bằng cách nào đó, điều mà rõ ràng là bạn không đề cập đến việc bạn dự định làm, thì không có gì sai với cách tiếp cận này! Lo lắng về mã hóa chỉ làm cho cuộc sống của bạn phức tạp hơn mà không có lý do thực sự.

Lợi ích bổ sung cho phương pháp này:

Sẽ không có vấn đề gì nếu chuỗi chứa các ký tự không hợp lệ, bởi vì bạn vẫn có thể lấy dữ liệu và xây dựng lại chuỗi gốc!

Nó sẽ được mã hóa và giải mã giống nhau, bởi vì bạn chỉ đang nhìn vào các byte .

Tuy nhiên, nếu bạn đã sử dụng một mã hóa cụ thể, nó sẽ gây rắc rối cho việc mã hóa / giải mã các ký tự không hợp lệ.

Nó phụ thuộc vào mã hóa chuỗi của bạn ( ASCII , UTF-8 , ...).

Ví dụ:

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

Một mẫu nhỏ tại sao mã hóa lại quan trọng:

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 đơn giản là không được trang bị để đối phó với các ký tự đặc biệt.

Trong nội bộ, .NET framework sử dụng UTF-16 để biểu diễn các chuỗi, vì vậy nếu bạn chỉ muốn lấy các byte chính xác mà .NET sử dụng, hãy sử dụng System.Text.Encoding.Unicode.GetBytes (...).

Xem Mã hóa ký tự trong .NET Framework (MSDN) để biết thêm thông tin.

Câu trả lời được chấp nhận là rất, rất phức tạp. Sử dụng các lớp .NET đi kèm cho việc này:

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

Đừng phát minh lại bánh xe nếu bạn không phải ...

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

Bạn cần đưa mã hóa vào tài khoản, vì 1 ký tự có thể được biểu thị bằng 1 hoặc nhiều byte (tối đa khoảng 6) và các mã hóa khác nhau sẽ xử lý các byte này khác nhau.

Joel có một bài viết về điều này:

Tối thiểu tuyệt đối Mỗi nhà phát triển phần mềm Tuyệt đối, Tích cực phải biết về bộ ký tự và Unicode (Không có lý do!)

Đây là một câu hỏi phổ biến. Điều quan trọng là phải hiểu những gì tác giả câu hỏi đang hỏi, và nó khác với những gì có thể là nhu cầu phổ biến nhất. Để ngăn chặn việc sử dụng sai mã không cần thiết, tôi đã trả lời sau.

Nhu cầu chung

Mỗi chuỗi có một bộ ký tự và mã hóa. Khi bạn chuyển đổi một System.Stringđối tượng thành một mảng, System.Bytebạn vẫn có một bộ ký tự và mã hóa. Đối với hầu hết các cách sử dụng, bạn sẽ biết bộ ký tự và mã hóa nào bạn cần và .NET giúp việc "sao chép với chuyển đổi" trở nên đơn giản. Chỉ cần chọn Encodinglớp thích hợp .

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

Việc chuyển đổi có thể cần xử lý các trường hợp trong đó bộ ký tự đích hoặc mã hóa không hỗ trợ ký tự trong nguồn. Bạn có một số lựa chọn: ngoại lệ, thay thế hoặc bỏ qua. Chính sách mặc định là thay thế '?'.

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

Rõ ràng, chuyển đổi không nhất thiết là mất mát!

Lưu ý: Đối với System.Stringbộ ký tự nguồn là Unicode.

Điều khó hiểu duy nhất là .NET sử dụng tên của một bộ ký tự cho tên của một mã hóa cụ thể của bộ ký tự đó. Encoding.Unicodenên được gọi Encoding.UTF16.

Đó là cho hầu hết các công dụng. Nếu đó là những gì bạn cần, dừng đọc ở đây. Xem bài viết vui nhộn Joel Spolsky nếu bạn không hiểu mã hóa là gì.

Cần cụ thể

Bây giờ, tác giả câu hỏi hỏi, "Mỗi chuỗi được lưu trữ dưới dạng một mảng byte, phải không? Tại sao tôi không thể có các byte đó?"

Anh ta không muốn bất kỳ chuyển đổi.

Từ thông số kỹ thuật C # :

Xử lý ký tự và chuỗi trong C # sử dụng mã hóa Unicode. Kiểu char đại diện cho một đơn vị mã UTF-16 và loại chuỗi đại diện cho một chuỗi các đơn vị mã UTF-16.

Vì vậy, chúng tôi biết rằng nếu chúng tôi yêu cầu chuyển đổi null (nghĩa là từ UTF-16 sang UTF-16), chúng tôi sẽ nhận được kết quả mong muốn:

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

Nhưng để tránh đề cập đến mã hóa, chúng ta phải làm theo cách khác. Nếu một kiểu dữ liệu trung gian có thể chấp nhận được, có một lối tắt khái niệm cho điều này:

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

Điều đó không mang lại cho chúng ta kiểu dữ liệu mong muốn nhưng câu trả lời của Mehrdad cho thấy cách chuyển đổi mảng Char này thành mảng Byte bằng cách sử dụng BlockCopy . Tuy nhiên, điều này sao chép chuỗi hai lần! Và, nó quá rõ ràng sử dụng mã dành riêng cho mã hóa: kiểu dữ liệu System.Char.

Cách duy nhất để có được các byte thực tế mà String được lưu trữ là sử dụng một con trỏ. Các fixedtuyên bố cho phép lấy địa chỉ của giá trị. Từ thông số kỹ thuật C #:

[Đối với] một biểu thức của chuỗi kiểu, ... trình khởi tạo sẽ tính địa chỉ của ký tự đầu tiên trong chuỗi.

Để làm như vậy, trình biên dịch ghi mã bỏ qua các phần khác của đối tượng chuỗi với RuntimeHelpers.OffsetToStringData. Vì vậy, để có được các byte thô, chỉ cần tạo một con trỏ tới chuỗi và sao chép số byte cần thiết.

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

Như @CodesInChaos đã chỉ ra, kết quả phụ thuộc vào độ bền của máy. Nhưng tác giả câu hỏi không quan tâm đến điều đó.

Phần đầu tiên của câu hỏi của bạn (làm thế nào để lấy byte) đã được người khác trả lời: tìm trong System.Text.Encodingkhông gian tên.

Tôi sẽ giải quyết câu hỏi tiếp theo của bạn: tại sao bạn cần chọn một mã hóa? Tại sao bạn không thể có được điều đó từ chính lớp chuỗi?

Câu trả lời là hai phần.

Trước hết, các byte được sử dụng bên trong lớp chuỗi không thành vấn đề và bất cứ khi nào bạn cho rằng chúng có khả năng gây ra lỗi.

Nếu chương trình của bạn hoàn toàn nằm trong thế giới .Net thì bạn không cần phải lo lắng về việc nhận mảng byte cho chuỗi, ngay cả khi bạn đang gửi dữ liệu qua mạng. Thay vào đó, hãy sử dụng .Net serialization để lo lắng về việc truyền dữ liệu. Bạn không còn lo lắng về các byte thực tế nữa: trình định dạng Nối tiếp thực hiện điều đó cho bạn.

Mặt khác, nếu bạn đang gửi các byte này ở đâu đó mà bạn không thể đảm bảo sẽ lấy dữ liệu từ luồng nối tiếp .Net thì sao? Trong trường hợp này, bạn chắc chắn cần phải lo lắng về mã hóa, bởi vì rõ ràng hệ thống bên ngoài này quan tâm. Vì vậy, một lần nữa, các byte bên trong được sử dụng bởi chuỗi không thành vấn đề: bạn cần chọn một mã hóa để bạn có thể rõ ràng về mã hóa này ở đầu nhận, ngay cả khi đó là cùng một mã hóa được sử dụng bởi .Net.

Tôi hiểu rằng trong trường hợp này, bạn có thể thích sử dụng các byte thực được lưu trữ bởi biến chuỗi trong bộ nhớ nếu có thể, với ý tưởng rằng nó có thể lưu một số công việc tạo luồng byte của bạn. Tuy nhiên, tôi nói với bạn điều đó không quan trọng so với việc đảm bảo rằng đầu ra của bạn được hiểu ở đầu kia và để đảm bảo rằng bạn phải rõ ràng với mã hóa của mình. Ngoài ra, nếu bạn thực sự muốn khớp các byte nội bộ của mình, bạn có thể chỉ cần chọn Unicodemã hóa và nhận mức tiết kiệm hiệu suất đó.

Điều này đưa tôi đến phần thứ hai ... chọn Unicodemã hóa là bảo .Net sử dụng các byte bên dưới. Bạn cần phải chọn mã hóa này, bởi vì khi một số Unicode-Plus mới xuất hiện, thời gian chạy .Net cần được tự do sử dụng mô hình mã hóa mới hơn, tốt hơn này mà không làm hỏng chương trình của bạn. Nhưng, hiện tại (và tương lai có thể thấy được), chỉ cần chọn mã hóa Unicode sẽ mang lại cho bạn những gì bạn muốn.

Điều quan trọng là phải hiểu chuỗi của bạn phải được viết lại thành dây và điều đó liên quan đến ít nhất một số bản dịch của mẫu bit ngay cả khi bạn sử dụng mã hóa phù hợp . Máy tính cần tính đến những thứ như Big vs Little Endian, thứ tự byte mạng, gói, thông tin phiên, v.v.

Chỉ để chứng minh rằng câu trả lời âm thanh của Mehrdrad hoạt động, cách tiếp cận của anh ta thậm chí có thể duy trì các nhân vật thay thế không ghép đôi (trong đó nhiều người đã chống lại câu trả lời của tôi, nhưng trong đó mọi người đều có tội như nhau, ví dụ System.Text.Encoding.UTF8.GetBytes, System.Text.Encoding.Unicode.GetBytesnhững phương pháp mã hóa đó không thể duy trì sự thay thế cao d800ví dụ như các ký tự và những ký tự chỉ thay thế các ký tự thay thế cao bằng giá trị 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);
    }        
}

Đầu ra:

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

Hãy thử điều đó với System.Text.Encoding.UTF8.GetBytes hoặc System.Text.Encoding.Unicode.GetBytes , họ sẽ chỉ thay thế các ký tự thay thế cao bằng giá trị fffd

Mỗi khi có một chuyển động trong câu hỏi này, tôi vẫn nghĩ về một bộ nối tiếp (có thể là từ Microsoft hoặc từ thành phần bên thứ 3) có thể duy trì các chuỗi ngay cả khi nó chứa các ký tự thay thế không ghép cặp; Tôi google cái này mỗi giờ và sau đó: tuần tự hóa ghép cặp ký tự thay thế .NET . Điều này không làm tôi mất ngủ, nhưng thật khó chịu khi thỉnh thoảng có ai đó bình luận về câu trả lời của tôi rằng nó thật thiếu sót, nhưng câu trả lời của họ cũng không hoàn hảo khi nói đến các nhân vật thay thế không ghép đôi.

Darn, Microsoft nên chỉ được sử dụng System.Buffer.BlockCopytrong nó BinaryFormatterツ

谢谢！

Hãy thử điều này, rất ít mã:

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

Chà, tôi đã đọc tất cả các câu trả lời và chúng là về việc sử dụng mã hóa hoặc một về việc tuần tự hóa làm giảm các chất thay thế không ghép đôi.

Thật tệ khi chuỗi, ví dụ, đến từ SQL Server , nơi nó được xây dựng từ việc lưu trữ mảng byte, ví dụ, hàm băm mật khẩu. Nếu chúng ta bỏ bất cứ thứ gì từ nó, nó sẽ lưu trữ một hàm băm không hợp lệ và nếu chúng ta muốn lưu trữ nó trong XML, chúng ta muốn giữ nguyên nó (vì trình soạn thảo XML sẽ loại bỏ một ngoại lệ đối với bất kỳ thay thế nào được tìm thấy).

Vì vậy, tôi sử dụng mã hóa Base64 của mảng byte trong những trường hợp như vậy, nhưng này, trên Internet chỉ có một giải pháp cho vấn đề này trong C #, và nó có lỗi trong đó và chỉ là một cách, vì vậy tôi đã sửa lỗi và viết lại thủ tục. Bạn đang ở đây, nhân viên của Google trong tương lai:

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

Ngoài ra xin vui lòng giải thích tại sao mã hóa nên được xem xét. Tôi không thể đơn giản nhận được byte nào mà chuỗi đã được lưu trữ? Tại sao sự phụ thuộc này vào mã hóa? !!!

Bởi vì không có thứ gọi là "byte của chuỗi".

Một chuỗi (hoặc tổng quát hơn, một văn bản) bao gồm các ký tự: chữ cái, chữ số và các ký hiệu khác. Đó là tất cả. Máy tính, tuy nhiên, không biết gì về các nhân vật; họ chỉ có thể xử lý byte. Do đó, nếu bạn muốn lưu trữ hoặc truyền văn bản bằng cách sử dụng máy tính, bạn cần chuyển đổi các ký tự thành byte. Làm thế nào để bạn làm điều đó? Đây là nơi mã hóa đến hiện trường.

Mã hóa không là gì ngoài một quy ước để dịch các ký tự logic thành các byte vật lý. Mã hóa đơn giản và nổi tiếng nhất là ASCII, và đó là tất cả những gì bạn cần nếu bạn viết bằng tiếng Anh. Đối với các ngôn ngữ khác, bạn sẽ cần mã hóa hoàn chỉnh hơn, trở thành bất kỳ hương vị Unicode nào là sự lựa chọn an toàn nhất hiện nay.

Vì vậy, trong ngắn hạn, cố gắng "lấy các byte của một chuỗi mà không sử dụng mã hóa" là không thể như "viết một văn bản mà không sử dụng bất kỳ ngôn ngữ nào".

Nhân tiện, tôi thực sự khuyên bạn (và bất cứ ai, vì vấn đề đó) nên đọc phần khôn ngoan nhỏ này: Tối thiểu tuyệt đối Mỗi nhà phát triển phần mềm Tuyệt đối, Phải tích cực phải biết về Unicode và Bộ ký tự (Không có lý do!)

C # để chuyển đổi a stringthành một bytemảng:

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

Bạn có thể sử dụng đoạn mã sau để chuyển đổi giữa chuỗi và mảng 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);

Với sự ra đời của Span<T>C # 7.2, kỹ thuật chính tắc để nắm bắt biểu diễn bộ nhớ cơ bản của chuỗi thành một mảng byte được quản lý là:

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

Chuyển đổi nó trở lại phải là một công cụ không bắt đầu bởi vì điều đó có nghĩa là trên thực tế bạn đang diễn giải dữ liệu bằng cách nào đó, nhưng vì mục đích hoàn chỉnh:

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

Các tên NonPortableCastvà DangerousGetPinnableReferencenên tiếp tục lập luận rằng bạn có thể không nên làm điều này.

Lưu ý rằng làm việc với Span<T>yêu cầu cài đặt gói System.Memory NuGet .

Bất kể, câu hỏi ban đầu thực tế và nhận xét tiếp theo ngụ ý rằng bộ nhớ cơ bản không bị "giải thích" (mà tôi cho rằng có nghĩa là không được sửa đổi hoặc đọc vượt quá nhu cầu viết như hiện tại), cho thấy rằng việc thực hiện Streamlớp này nên được sử dụng thay vì lý luận về dữ liệu dưới dạng chuỗi.

Tôi không chắc chắn, nhưng tôi nghĩ chuỗi lưu trữ thông tin của nó dưới dạng một mảng Chars, không hiệu quả với byte. Cụ thể, định nghĩa của Char là "Đại diện cho một ký tự Unicode".

lấy ví dụ mẫu này:

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

Xin lưu ý rằng câu trả lời Unicode là 14 byte trong cả hai trường hợp, trong khi câu trả lời UTF-8 chỉ có 9 byte cho lần đầu tiên và chỉ 7 cho lần thứ hai.

Vì vậy, nếu bạn chỉ muốn các byte được sử dụng bởi chuỗi, chỉ cần sử dụng Encoding.Unicode, nhưng nó sẽ không hiệu quả với không gian lưu trữ.

Vấn đề chính là một glyph trong chuỗi mất 32 bit (16 bit cho mã ký tự) nhưng một byte chỉ có 8 bit dự phòng. Ánh xạ một-một không tồn tại trừ khi bạn giới hạn bản thân trong các chuỗi chỉ chứa các ký tự ASCII. System.Text.Encoding có rất nhiều cách để ánh xạ chuỗi thành byte [], bạn cần chọn một cách tránh mất thông tin và khách hàng của bạn dễ dàng sử dụng khi cô ấy cần ánh xạ byte [] trở lại chuỗi .

Utf8 là một mã hóa phổ biến, nó nhỏ gọn và không mất mát.

Sử dụng:

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

Kết quả là:

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

Cách nhanh nhất

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

EDIT như Makotosan nhận xét đây là cách tốt nhất:

Encoding.UTF8.GetBytes(text)

Làm cách nào để chuyển đổi một chuỗi thành một byte [] trong .NET (C #) mà không chỉ định thủ công một mã hóa cụ thể?

Một chuỗi trong .NET biểu thị văn bản dưới dạng một chuỗi các đơn vị mã UTF-16, do đó, các byte đã được mã hóa trong bộ nhớ trong UTF-16.

Câu trả lời của Mehrdad

Bạn có thể sử dụng câu trả lời của Mehrdad , nhưng thực tế nó sử dụng mã hóa vì ký tự là UTF-16. Nó gọi ToCharArray, việc nhìn vào nguồn sẽ tạo char[]và sao chép bộ nhớ vào nó trực tiếp. Sau đó, nó sao chép dữ liệu vào một mảng byte cũng được phân bổ. Vì vậy, dưới mui xe, nó sao chép các byte bên dưới hai lần và phân bổ một mảng char không được sử dụng sau cuộc gọi.

Câu trả lời của Tom Blodget

Câu trả lời của Tom Blodget nhanh hơn 20-30% so với Mehrdad vì nó bỏ qua bước trung gian phân bổ một mảng char và sao chép các byte vào nó, nhưng nó yêu cầu bạn biên dịch với /unsafetùy chọn. Nếu bạn hoàn toàn không muốn sử dụng mã hóa, tôi nghĩ rằng đây là cách để đi. Nếu bạn đặt thông tin đăng nhập mã hóa của mình bên trong fixedkhối, bạn thậm chí không cần phân bổ một mảng byte riêng biệt và sao chép các byte vào nó.

Ngoài ra, tại sao nên mã hóa? Tôi không thể đơn giản nhận được byte nào mà chuỗi đã được lưu trữ? Tại sao có sự phụ thuộc vào mã hóa ký tự?

Bởi vì đó là cách thích hợp để làm điều đó. stringlà một sự trừu tượng.

Sử dụng mã hóa có thể gây rắc rối cho bạn nếu bạn có 'chuỗi' với các ký tự không hợp lệ, nhưng điều đó không nên xảy ra. Nếu bạn đang nhận dữ liệu vào chuỗi của mình với các ký tự không hợp lệ, bạn đang làm sai. Có lẽ bạn nên sử dụng một mảng byte hoặc mã hóa Base64 để bắt đầu.

Nếu bạn sử dụng System.Text.Encoding.Unicode, mã của bạn sẽ linh hoạt hơn. Bạn không phải lo lắng về tính lâu dài của hệ thống mà mã của bạn sẽ chạy. Bạn không cần phải lo lắng nếu phiên bản tiếp theo của CLR sẽ sử dụng mã hóa ký tự nội bộ khác.

Tôi nghĩ rằng câu hỏi không phải là lý do tại sao bạn muốn lo lắng về mã hóa, nhưng tại sao bạn muốn bỏ qua nó và sử dụng một cái gì đó khác. Mã hóa có nghĩa là đại diện cho sự trừu tượng của một chuỗi trong một chuỗi các byte. System.Text.Encoding.Unicodesẽ cung cấp cho bạn một mã hóa thứ tự byte cuối cùng và sẽ thực hiện tương tự trên mọi hệ thống, bây giờ và trong tương lai.

Cách tiếp cận gần nhất với câu hỏi của OP là Tom Blodget, thực sự đi vào đối tượng và trích xuất các byte. Tôi nói gần nhất bởi vì nó phụ thuộc vào việc thực hiện String Object.

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

Chắc chắn, nhưng đó là nơi phát sinh lỗi cơ bản trong câu hỏi. Chuỗi là một đối tượng có thể có cấu trúc dữ liệu thú vị. Chúng tôi đã biết điều đó, bởi vì nó cho phép các chất thay thế không ghép đôi được lưu trữ. Nó có thể lưu trữ chiều dài. Nó có thể giữ một con trỏ tới từng người thay thế 'được ghép đôi' cho phép đếm nhanh. V.v. Tất cả các byte bổ sung này không phải là một phần của dữ liệu ký tự.

Những gì bạn muốn là mỗi byte của nhân vật trong một mảng. Và đó là nơi 'mã hóa' xuất hiện. Theo mặc định, bạn sẽ nhận được UTF-16LE. Nếu bạn không quan tâm đến các byte ngoại trừ chuyến đi khứ hồi thì bạn có thể chọn bất kỳ mã hóa nào bao gồm 'mặc định' và chuyển đổi lại sau (giả sử các tham số tương tự như mã hóa mặc định là gì, điểm mã, sửa lỗi , những thứ được cho phép như người thay thế không ghép đôi, v.v.

Nhưng tại sao lại để 'mã hóa' thành ma thuật? Tại sao không chỉ định mã hóa để bạn biết bạn sẽ nhận được byte nào?

"Why is there a dependency on character encodings?"

Mã hóa (trong ngữ cảnh này) chỉ đơn giản là các byte đại diện cho chuỗi của bạn. Không phải là byte của đối tượng chuỗi. Bạn muốn các byte mà chuỗi đã được lưu trữ - đây là nơi câu hỏi được hỏi một cách ngây thơ. Bạn muốn các byte của chuỗi trong một mảng liền kề đại diện cho chuỗi và không phải tất cả các dữ liệu nhị phân khác mà một đối tượng chuỗi có thể chứa.

Có nghĩa là làm thế nào một chuỗi được lưu trữ là không liên quan. Bạn muốn một chuỗi "Được mã hóa" thành byte trong một mảng byte.

Tôi thích câu trả lời của Tom Bloget vì anh ấy đưa bạn về hướng 'byte của đối tượng chuỗi'. Mặc dù điều đó phụ thuộc vào việc thực hiện và bởi vì anh ta nhìn trộm vào bên trong nên có thể khó khôi phục lại một bản sao của chuỗi.

Phản ứng của Mehrdad là sai bởi vì nó sai lệch ở cấp độ khái niệm. Bạn vẫn có một danh sách các byte, được mã hóa. Giải pháp đặc biệt của anh ấy cho phép những người thay thế không ghép đôi được bảo tồn - điều này phụ thuộc vào việc thực hiện. Giải pháp cụ thể của anh ta sẽ không tạo ra các byte chính xác của chuỗi nếu GetBytestrả về chuỗi theo UTF-8 theo mặc định.

Tôi đã thay đổi suy nghĩ về điều này (giải pháp của Mehrdad) - đây không phải là lấy byte của chuỗi; thay vào đó, nó nhận được các byte của mảng ký tự được tạo từ chuỗi. Bất kể mã hóa, kiểu dữ liệu char trong c # là một kích thước cố định. Điều này cho phép tạo ra một mảng byte có độ dài nhất quán và nó cho phép mảng ký tự được sao chép dựa trên kích thước của mảng byte. Vì vậy, nếu mã hóa là UTF-8, nhưng mỗi char là 6 byte để chứa giá trị utf8 lớn nhất, nó vẫn hoạt động. Vì vậy, thực sự - mã hóa của nhân vật không quan trọng.

Nhưng một chuyển đổi đã được sử dụng - mỗi ký tự được đặt vào một hộp có kích thước cố định (loại ký tự của c #). Tuy nhiên, đại diện đó không quan trọng, về mặt kỹ thuật là câu trả lời cho OP. Vì vậy - nếu bạn định chuyển đổi bằng mọi cách ... Tại sao không 'mã hóa'?

Bạn có thể sử dụng đoạn mã sau để chuyển đổi stringthành a byte arraytrong .NET

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

Nếu bạn thực sự muốn một bản sao của các byte bên dưới của một chuỗi, bạn có thể sử dụng một hàm giống như hàm theo sau. Tuy nhiên, bạn không nên đọc tiếp để tìm hiểu lý do tại sao.

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

Hàm này sẽ giúp bạn có một bản sao các byte nằm dưới chuỗi của bạn, khá nhanh chóng. Bạn sẽ nhận được các byte đó theo bất cứ cách nào chúng mã hóa trên hệ thống của bạn. Mã hóa này gần như chắc chắn là UTF-16LE nhưng đó là một chi tiết triển khai bạn không cần phải quan tâm.

Sẽ an toàn hơn, đơn giản hơn và đáng tin cậy hơn nếu chỉ gọi,

System.Text.Encoding.Unicode.GetBytes()

Trong tất cả khả năng, điều này sẽ cho kết quả tương tự, dễ nhập hơn và các byte sẽ luôn đi khứ hồi với một cuộc gọi đến

System.Text.Encoding.Unicode.GetString()

Đây là cách thực hiện không an toàn Stringđể Byte[]chuyển đổi:

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

Nó nhanh hơn cách của người được chấp nhận, ngay cả khi không thanh lịch như nó. Dưới đây là điểm chuẩn Đồng hồ bấm giờ của tôi trên 10000000 lần lặp:

[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

Để sử dụng nó, bạn phải đánh dấu vào "Cho phép mã không an toàn" trong thuộc tính xây dựng dự án của bạn. Theo .NET Framework 3.5, phương thức này cũng có thể được sử dụng làm chuỗi mở rộng:

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

Đơn giản chỉ cần sử dụng này:

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

Chuỗi có thể được chuyển đổi thành mảng byte theo một số cách khác nhau, do thực tế sau: .NET hỗ trợ Unicode và Unicode tiêu chuẩn hóa một số mã hóa khác nhau được gọi là UTF. Chúng có độ dài biểu diễn byte khác nhau nhưng tương đương theo nghĩa đó là khi một chuỗi được mã hóa, nó có thể được mã hóa trở lại chuỗi, nhưng nếu chuỗi được mã hóa bằng một UTF và được giải mã theo giả định UTF khác nhau nếu có thể được vặn lên.

Ngoài ra, .NET hỗ trợ mã hóa phi Unicode, nhưng chúng không hợp lệ trong trường hợp chung (sẽ chỉ hợp lệ nếu một tập hợp con giới hạn của điểm mã Unicode được sử dụng trong một chuỗi thực, chẳng hạn như ASCII). Trong nội bộ, .NET hỗ trợ UTF-16, nhưng để thể hiện luồng, UTF-8 thường được sử dụng. Nó cũng là một tiêu chuẩn thực tế cho Internet.

Không có gì đáng ngạc nhiên, việc tuần tự hóa chuỗi thành một mảng byte và giải tuần tự hóa được hỗ trợ bởi lớp System.Text.Encoding, đây là một lớp trừu tượng; các lớp dẫn xuất của nó hỗ trợ mã hóa cụ thể: ASCIIEncodingvà bốn UTF ( System.Text.UnicodeEncodinghỗ trợ UTF-16)

Tham khảo liên kết này.

Để tuần tự hóa đến một mảng byte bằng cách sử dụng System.Text.Encoding.GetBytes. Đối với việc sử dụng hoạt động nghịch đảo System.Text.Encoding.GetChars. Hàm này trả về một mảng các ký tự, vì vậy để có được một chuỗi, hãy sử dụng hàm tạo chuỗi System.String(char[]).
Tham khảo trang này.

Thí dụ:

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

Nó phụ thuộc vào những gì bạn muốn các byte CHO

Điều này là do, như Tyler rất thông minh đã nói , "Chuỗi không phải là dữ liệu thuần túy. Họ cũng có thông tin ." Trong trường hợp này, thông tin là một mã hóa được giả sử khi chuỗi được tạo.

Giả sử rằng bạn có dữ liệu nhị phân (chứ không phải văn bản) được lưu trữ trong một chuỗi

Điều này dựa trên nhận xét của OP về câu hỏi của chính anh ấy và là câu hỏi chính xác nếu tôi hiểu gợi ý của OP trong trường hợp sử dụng.

Lưu trữ dữ liệu nhị phân trong chuỗi có lẽ là cách tiếp cận sai vì mã hóa giả định được đề cập ở trên! Bất cứ chương trình hay thư viện nào lưu trữ dữ liệu nhị phân đó trong mộtstring (thay vì một byte[]mảng phù hợp hơn) đã thua trận trước khi nó bắt đầu. Nếu họ đang gửi byte cho bạn trong yêu cầu / phản hồi REST hoặc bất cứ điều gì phải truyền chuỗi, Base64 sẽ là phương pháp phù hợp.

Nếu bạn có một chuỗi văn bản với một mã hóa không xác định

Mọi người khác trả lời sai câu hỏi này không chính xác.

Nếu chuỗi có vẻ tốt như hiện tại, chỉ cần chọn một mã hóa (tốt nhất là bắt đầu bằng UTF), sử dụng System.Text.Encoding.???.GetBytes()hàm tương ứng và cho biết bất cứ ai bạn cung cấp byte cho mã hóa mà bạn đã chọn.

Khi được hỏi bạn định làm gì với các byte, bạn đã trả lời :

Tôi sẽ mã hóa nó. Tôi có thể mã hóa nó mà không cần chuyển đổi nhưng tôi vẫn muốn biết tại sao mã hóa lại xuất hiện ở đây. Chỉ cần cho tôi các byte là những gì tôi nói.

Bất kể bạn có ý định gửi dữ liệu được mã hóa này qua mạng hay không, tải lại vào bộ nhớ sau hoặc hấp nó sang quy trình khác, rõ ràng bạn đang có ý định giải mã nó vào một lúc nào đó. Trong trường hợp đó, câu trả lời là bạn đang xác định một giao thức truyền thông. Một giao thức truyền thông không nên được xác định theo các chi tiết triển khai của ngôn ngữ lập trình và thời gian chạy liên quan của nó. Cái này có một vài nguyên nhân:

• Bạn có thể cần giao tiếp với một quy trình được thực hiện bằng ngôn ngữ hoặc thời gian chạy khác. (Điều này có thể bao gồm một máy chủ đang chạy trên một máy khác hoặc gửi chuỗi đến máy khách trình duyệt JavaScript chẳng hạn.)
• Chương trình có thể được thực hiện lại bằng một ngôn ngữ hoặc thời gian chạy khác trong tương lai.
• Việc triển khai .NET có thể thay đổi biểu diễn bên trong của chuỗi. Bạn có thể nghĩ rằng điều này nghe có vẻ xa vời, nhưng điều này thực sự đã xảy ra trong Java 9 để giảm mức sử dụng bộ nhớ. Không có lý do gì .NET không thể làm theo. Skeet cho rằng UTF-16 có thể không tối ưu ngày hôm nay làm tăng biểu tượng cảm xúc và các khối Unicode khác cần nhiều hơn 2 byte để thể hiện, làm tăng khả năng biểu diễn bên trong có thể thay đổi trong tương lai.

Để giao tiếp (với quy trình hoàn toàn khác biệt hoặc với cùng một chương trình trong tương lai), bạn cần xác định nghiêm ngặt giao thức của mình để giảm thiểu khó khăn khi làm việc với nó hoặc vô tình tạo ra lỗi. Tùy thuộc vào đại diện nội bộ của .NET không phải là một định nghĩa chặt chẽ, rõ ràng hoặc thậm chí được đảm bảo là định nghĩa nhất quán. Mã hóa tiêu chuẩn là một định nghĩa nghiêm ngặt sẽ không làm bạn thất vọng trong tương lai.

Nói cách khác, bạn không thể đáp ứng yêu cầu về tính nhất quán mà không chỉ định mã hóa.

Bạn chắc chắn có thể chọn sử dụng trực tiếp UTF-16 nếu bạn thấy rằng quy trình của mình hoạt động tốt hơn đáng kể vì .NET sử dụng nội bộ hoặc vì bất kỳ lý do nào khác, nhưng bạn cần chọn mã hóa rõ ràng và thực hiện các chuyển đổi đó một cách rõ ràng trong mã của mình thay vì phụ thuộc về triển khai nội bộ của .NET.

Vì vậy, chọn một mã hóa và sử dụng nó:

using System.Text;

// ...

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

Như bạn có thể thấy, thực tế cũng ít mã hơn khi chỉ sử dụng các đối tượng mã hóa được tích hợp sẵn để thực hiện các phương thức đọc / ghi của riêng bạn.

Hai lối:

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

Và,

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

Tôi có xu hướng sử dụng cái dưới thường xuyên hơn cái trên, không đánh giá chúng về tốc độ.

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