提问



如何在不手动指定特定编码的情况下,在.NET(C#)中将string转换为byte[]?


我要加密字符串。我可以加密它而不需要转换,但我仍然想知道为什么编码在这里发挥作用。


另外,为什么要考虑编码?我不能简单地得到字符串存储的字节数吗?为什么对字符编码有依赖?

最佳参考


与此处的答案相反,您不必担心编码 如果 不需要解释的字节!



就像你提到的那样,你的目标就是获取字符串存储在中的字节数。

(当然,能够从字节中重新构造字符串。)


为了实现这些目标,我老老实实地不了解人们为什么一直告诉你需要编码。你当然不需要担心编码。



只需这样做:


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


只要你的程序(或其他程序)不试图以某种方式解释字节,你显然没有提到你打算这样做,那么没什么这种方法有误!担心编码只会让你的生活更加复杂,没有真正的理由。


这种方法的其他好处:



如果字符串包含无效字符,则无关紧要,因为无论如何您仍然可以获取数据并重建原始字符串!



它将被编码和解码相同,因为你只是在查看字节。


但是,如果你使用了特定的编码,那么编码/解码无效字符就会给你带来麻烦。

其它参考1


这取决于你的字符串的编码(ASCII,UTF-8,...)。[87] [88]


例如:


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


编码重要的一个小例子:


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根本不具备处理特殊字符的能力。


在内部,.NET框架使用UTF-16来表示字符串,因此如果您只想获取.NET使用的确切字节,请使用System.Text.Encoding.Unicode.GetBytes (...)[89]


有关详细信息,请参阅.NET Framework中的字符编码(MSDN)。[90]

其它参考2


接受的答案非常非常复杂。使用包含的.NET类:


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


如果你不必......重新发明轮子......

其它参考3


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

其它参考4


您需要考虑编码,因为1个字符可以由1个或更多个字节(最多约6个)表示,不同的编码将以不同的方式处理这些字节。


乔尔有一个帖子:



  绝对最低每个软件开发人员绝对必须知道Unicode和字符集(没有借口!)[91]


其它参考5


这是一个很受欢迎的问题。重要的是要理解作者提出的问题,并且它与最常见的需求不同。为了阻止在不需要的地方滥用代码,我先回答了后来的问题。


共同需要



每个字符串都有一个字符集和编码。将System.String对象转换为System.Byte数组时,仍然有字符集和编码。 对于大多数用法,你都知道你需要哪个字符集和编码,.NET可以很容易地通过转换进行复制。只需选择合适的Encoding类。


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


转换可能需要处理目标字符集或编码不支持源中的字符的情况。你有一些选择:例外,替换或跳过。默认策略是替换?。


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


显然,转换不一定是无损的!


注意:对于System.String,源字符集是Unicode。


唯一令人困惑的是,.NET使用字符集的名称作为该字符集的一个特定编码的名称。 Encoding.Unicode应该被称为Encoding.UTF16


这就是大多数用法。如果这就是你需要的,请不要在这里阅读。如果你不明白编码是什么,请参阅有趣的Joel Spolsky文章。[92]


特殊需要



现在,问题作者问:每个字符串都存储为一个字节数组,对吧?为什么我只能拥有那些字节?


他不想要任何转换。


来自C#规范:[93]



  C#中的字符和字符串处理使用Unicode编码。这个角色
  type表示UTF-16代码单元,字符串类型表示a
  UTF-16代码单元序列。



所以,我们知道如果我们要求空转换(即从UTF-16到UTF-16),我们将获得所需的结果:


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


但为了避免提及编码,我们必须采取另一种方式。如果中间数据类型是可接受的,则有一个概念性的快捷方式:


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


这并没有让我们得到所需的数据类型,但Mehrdad的答案显示了如何使用BlockCopy将此Char数组转换为Byte数组。但是,这会复制两次字符串!而且,它也明确使用特定于编码的代码:数据类型System.Char[95]


获取存储String的实际字节的唯一方法是使用指针。 fixed语句允许获取值的地址。来自C#规范:



  [[For]]一个string类型的表达式,...初始化程序计算
  字符串中第一个字符的地址。



为此,编译器使用RuntimeHelpers.OffsetToStringData将代码跳过写入字符串对象的其他部分。因此,要获取原始字节,只需创建指向字符串的指针并复制所需的字节数。


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


正如@CodesInChaos指出的那样,结果取决于机器的字节顺序。但问题的作者并不关心这一点。

其它参考6


只是为了证明Mehrdrad的正确答案是有效的,他的方法甚至可以坚持不成对的代理人物(其中许多人反对我的答案,但每个人都同样有罪,例如System.Text.Encoding.UTF8.GetBytesSystem.Text.Encoding.Unicode.GetBytes]];那些编码方法不能坚持高代理字符d800,而那些只是用值fffd替换高代理字符): [97]


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


输出:


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


尝试使用 System.Text.Encoding.UTF8.GetBytes System.Text.Encoding.Unicode.GetBytes ,它们只会替换值为 fffd的高代理字符


每当这个问题发生变化时,我仍然会想到一个序列化器(无论是来自微软还是来自第三方组件),即使它包含不成对的代理字符,它也能保持字符串;我不时地谷歌这个:序列化不成对的代理人物.NET 。这并没有让我失去任何睡眠,但是当有人评论我的答案它有缺陷时,它会有点烦人,但是当涉及到不成对的代理角色时,他们的答案同样存在缺陷。


Darn,微软应该在其BinaryFormatter

中使用System.Buffer.BlockCopy

谢谢!


其它参考7


试试这个,少了很多代码:


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

其它参考8


你的问题的第一部分(如何获取字节)已被其他人回答:查看System.Text.Encoding命名空间。


我将解决您的后续问题:为什么需要选择编码?为什么你不能从字符串类本身那里得到它?


答案分为两部分。


首先,字符串类内部使用的字节并不重要,而且只要你认为它们,你就可能会引入一个错误。


如果您的程序完全在.Net世界中,那么即使您通过网络发送数据,也不必担心为字符串获取字节数组。相反,使用.Net Serialization来担心传输数据。你不再担心实际的字节:序列化格式化器为你做了。


另一方面,如果你在某个地方发送这些字节,你不能保证从.Net序列化流中提取数据怎么办呢?在这种情况下,你肯定需要担心编码,因为显然这个外部系统很关心。所以再次,字符串使用的内部字节无关紧要:您需要选择一个编码,这样您就可以在接收端明确表示此编码,即使它与.Net内部使用的编码相同。


我知道在这种情况下,您可能更愿意在可能的情况下使用字符串变量存储在字节变量中的实际字节,并认为它可能会节省一些创建字节流的工作。但是,我告诉你它与确保你的输出在另一端被理解相比并不重要,并且保证你必须明确你的编码。另外,如果你真的想要匹配你的内部字节,你可以只选择Unicode编码,并节省性能。


这让我想到第二部分......选择Unicode编码 告诉.Net使用底层字节。你确实需要选择这种编码,因为当出现一些新奇的Unicode-Plus时,.Net运行时需要免费使用这种更新,更好的编码模型而不会破坏你的程序。但是,目前(以及可预见的未来),只需选择Unicode编码即可获得所需内容。


理解你的字符串必须重写为连线也很重要,即使你使用匹配的编码,这至少涉及位模式的一些翻译。计算机需要帐户适用于Big vs Little Endian,网络字节顺序,打包,会话信息等。

其它参考9


好吧,我已经阅读了所有的答案,他们是关于使用编码或一个关于序列化,删除不成对的代理人。


例如,字符串来自SQL Server,它是从存储的字节数组(例如,密码哈希)构建的。如果我们从中删除任何内容,它将存储无效的哈希值,如果我们想要将它存储在XML中,我们希望保持原样(因为XML编写器会在它找到的任何未配对的代理上删除异常。)[98]


在这种情况下我使用字节数组的Base64编码,但是,在互联网上只有一个解决方案,在C#中,它有bug,只有一种方式,所以我已经修复了这个bug并写回来了程序。你在这里,未来的googlers:[99]


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

其它参考10



  还请解释为什么要考虑编码。
  我不能简单地得到字符串存储的字节数吗?
  为什么这种依赖编码?!!!



因为没有字符串的字节之类的东西。


字符串(或更一般地说,文本)由字符组成:字母,数字和其他符号。这就是全部。然而,计算机对字符一无所知;它们只能处理字节。因此,如果要使用计算机存储或传输文本,则需要将字符转换为字节。如何处理那?编码到达现场的地方。


编码只不过是将逻辑字符转换为物理字节的惯例。最简单和最知名的编码是ASCII,如果你用英文写作,它就是你所需要的。对于其他语言,您将需要更完整的编码,任何Unicode风格都是当今最安全的选择。


因此,简而言之,尝试在不使用编码的情况下获取字符串的字节数与不使用任何语言编写文本一样不可能。


顺便说一句,我强烈建议你(以及任何人,就此而言)阅读这一小小的智慧:绝对最低每个软件开发人员绝对,必须知道关于Unicode和字符集(没有借口!)[100]

其它参考11


C#将string转换为byte数组:


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

其它参考12


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

其它参考13


您可以使用以下代码进行字符串和字节数组之间的转换。


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

其它参考14


我不确定,但我认为字符串将其信息存储为Chars数组,这对于字节来说是低效的。具体来说,Char的定义是表示Unicode字符。


以此示例示例:


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


请注意,两个实例中的Unicode答案都是14个字节,而UTF-8答案第一个只有9个字节,第二个只有7个字节。


因此,如果您只想要字符串使用的字节,只需使用Encoding.Unicode,但存储空间效率低下。

其它参考15


关键问题是字符串中的字形占用32位(字符代码为16位),但一个字节只有8位备用。除非您将自己限制为仅包含ASCII字符的字符串,否则不存在一对一映射.System.Text.Encoding有很多方法将字符串映射到byte [[]],您需要选择一个避免丢失的字符串当客户需要将byte [[]]映射回字符串时,客户端可以轻松使用这些信息。


Utf8是一种流行的编码,它紧凑而且没有损耗。

其它参考16


最快的方式


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


修改
正如Makotosan评论说这是现在最好的方式:


Encoding.UTF8.GetBytes(text)

其它参考17


使用:


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


结果是:


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

其它参考18


您可以使用以下代码在.NET中将string转换为byte array


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

其它参考19


最接近OP问题的方法是Tom Blodget,它实际上是进入对象并提取字节。我说最接近因为它取决于String对象的实现。


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


当然,但那就是问题出现的根本错误。字符串是一个可能有一个有趣的数据结构的对象。我们已经知道它确实存在,因为它允许存储未配对的代理。它可能存储长度。它可能会保留一个指向每个配对代理的指针,允许快速计数。等等。所有这些额外字节都不是字符数据的一部分。


你想要的是每个字符在数组中的字节。这就是编码的来源。默认情况下你会得到UTF-16LE。如果你不关心字节本身,除了往返之外你可以选择任何编码,包括默认,并稍后将其转换回来(假设相同的参数,例如默认编码,代码点,错误修复,允许的事情,如未配对的代理等)。


但为什么要将编码留给魔术呢?为什么不指定编码,以便您知道要获得的字节数?


"Why is there a dependency on character encodings?"


编码(在此上下文中)仅表示表示字符串的字节。不是字符串对象的字节。你想要存储字符串的字节 - 这是天真地问的问题。您希望字符串的字节在表示字符串的连续数组中,而不是字符串对象可能包含的所有其他二进制数据。


这意味着如何存储字符串是无关紧要的。您希望在字节数组中将字符串Encoded转换为字节。


我喜欢Tom Bloget的回答,因为他带你走向字符串对象的字节方向。虽然它依赖于实现,并且因为他在内部窥视,所以很难重新构建字符串的副本。


Mehrdad的回答是错误的,因为它在概念层面上有误导性。你仍然有一个字节列表,编码。他的特殊解决方案允许保留不成对的代理 - 这是依赖于实现的。他的特定解决方案不会产生字符串如果GetBytes默认返回UTF-8中的字符串,则s字节准确无误。





我已经改变了主意(Mehrdad的解决方案) - 这不是获取字符串的字节;而是获取从字符串创建的字符数组的字节。无论编码如何,char c#中的数据类型是固定大小。这允许生成一致的长度字节数组,并允许根据字节数组的大小重现字符数组。所以如果编码是UTF-8,但每个字符都是6个字节以容纳最大的utf8值,它仍然可以工作。所以确实 - 字符的编码无关紧要。


但是使用了一个转换 - 每个字符都放在一个固定大小的框中(c#的字符类型)。然而,这种表示无关紧要,这在技术上是OP的答案。所以 - 如果你要去无论如何转换...为什么不编码?

其它参考20


这是我StringByte[]转换的不安全实现:


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


它比被接受的anwser更快,即使不像它那样优雅。
这是我的超过10000000次迭代的秒表基准测试:


[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


要使用它,您必须在项目构建属性中勾选允许不安全代码。
根据.NET Framework 3.5,此方法也可用作String扩展:


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

其它参考21


两种方式:


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


和,


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


我倾向于比顶部更频繁地使用底部,而不是为了速度而对它们进行基准测试。

其它参考22


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

其它参考23


使用LINQ的简单代码


string s = "abc"
byte[] b = s.Select(e => (byte)e).ToArray();


编辑:如下所述,这不是一个好方法。


但您仍然可以使用它来更好地理解LINQ:


string s = "abc"
byte[] b = s.Cast<byte>().ToArray();

其它参考24


只需使用:


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

其它参考25


如果你真的想要一个字符串的底层字节的副本,你可以使用类似下面的函数。 但是,你不应该请继续阅读以找出原因。


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


这个函数会很快给你一个字符串底层字节的副本。您将以他们在您的系统上编码的任何方式获取这些字节。这种编码几乎肯定是UTF-16LE,但这是一个您不应该关心的实现细节。


只需打电话就可以更安全,更简单,更可靠


System.Text.Encoding.Unicode.GetBytes()


很可能这会产生相同的结果,更容易输入,并且字节将始终通过调用来往返


System.Text.Encoding.Unicode.GetString()

其它参考26


由于以下事实,字符串可以以几种不同的方式转换为字节数组:.NET支持Unicode,Unicode标准化了几种称为UTF的差异编码。它们具有不同长度的字节表示,但在这种意义上是等效的,当字符串被编码时,它可以被编码回字符串,但是如果字符串用一个UTF编码并且在假设不同的UTF下解码则可以拧紧向上。


此外,.NET支持非Unicode编码,但它们在一般情况下无效(仅当在实际字符串中使用有限的Unicode代码点子集时才有效,例如ASCII)。在.NET内部,.NET支持UTF-16,但对于流表示,通常使用UTF-8。它也是互联网的标准事实。


毫不奇怪,类System.Text.Encoding支持将字符串序列化为字节数组和反序列化,这是一个抽象类;它的派生类支持具体的编码:ASCIIEncoding和四个UTF(System.Text.UnicodeEncoding支持UTF-16)


参考此链接。[101]


使用System.Text.Encoding.GetBytes序列化为字节数组。对于逆运算,使用System.Text.Encoding.GetChars。此函数返回一个字符数组,因此要获取字符串,请使用字符串构造函数System.String(char[])

参考此页。[102]


例:


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

其它参考27


随着C#7.2发布Span<T>的出现,将字符串的底层内存表示捕获到托管字节数组的规范技术是:[103]


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


将其转换回来应该是一个非首发,因为这意味着你实际上是以某种方式解释数据,但为了完整起见:


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


名称NonPortableCastDangerousGetPinnableReference应该进一步证明你可能不应该这样做。


请注意,使用Span<T>需要安装System.Memory NuGet包。 [104]


无论如何,实际的原始问题和后续注释意味着底层内存没有被解释(我假设它不会被修改或读取超出按原样写入的需要),指示应该使用Stream类的某些实现,而不是根据字符串推断数据。

其它参考28


byte[]string:


        return BitConverter.ToString(bytes);

其它参考29


这取决于你想要的东西bytes FOR



这是因为,正如泰勒所说的那样,字符串不是纯粹的数据。他们也有信息。在这种情况下,信息是在创建字符串时假设的编码。 [106]


假设您有二进制数据(而不是文本)存储在字符串



这是基于OP对自己问题的评论,如果我理解OP对用例的暗示,这是正确的问题。


由于上面提到的假设编码,在字符串中存储二进制数据可能是错误的方法!无论在string(而不是byte[]数组中存储二进制数据的任何程序或库,在它开始之前已经失去了战斗。如果他们在REST请求/响应中发送字节给你,或者必须发送字符串的任何内容,那么Base64将是正确的方法。


如果您的文本字符串包含未知编码



其他人都错误地回答了这个错误的问题。


如果字符串看起来很好,只需选择一个编码(最好是以UTF开头的编码),使用相应的System.Text.Encoding.???.GetBytes()函数,并告诉你给哪个字节你选择的编码。