其他人已经回答了您问题的第一部分（如何获取字节）：查看System.Text.Encoding命名空间。

我将回答您的后续问题：为什么需要选择编码？为什么不能从字符串类本身获得这些信息？

答案分为两部分。

首先，字符串类内部使用的字节并不重要，只要假设它们存在，就可能引入错误。

如果您的程序完全在.Net世界中，那么您根本不需要担心获取字符串的字节数组，即使您正在通过网络发送数据。相反，请使用.Net Serialization来担心数据传输问题。您不再担心实际的字节数：Serialization格式化程序会为您提供。

另一方面，如果您将这些字节发送到某个无法保证将从.Net序列化流中提取数据的地方，该怎么办？在这种情况下，您确实需要担心编码问题，因为显然，这个外部系统关心编码问题。同样，字符串使用的内部字节无关紧要：您需要选择一种编码，以便在接收端明确该编码，即使它与.Net内部使用的编码相同。

我理解，在这种情况下，您可能更希望在可能的情况下使用字符串变量存储在内存中的实际字节，这样可以节省创建字节流的工作量。然而，我告诉你，与确保输出在另一端被理解，并保证编码必须明确相比，这并不重要。此外，如果您真的想匹配内部字节，您可以只选择Unicode编码，从而节省性能。

这让我进入第二部分。。。选择Unicode编码就是告诉.Net使用底层字节。您确实需要选择这种编码，因为当一些新的Unicode Plus问世时，.Net运行时需要自由使用这种更新、更好的编码模型，而不会破坏您的程序。但是，目前（以及可预见的未来），只要选择Unicode编码就可以满足您的需要。

理解字符串必须重写为线也是很重要的，即使使用匹配的编码，也至少需要对位模式进行一些转换。计算机需要考虑诸如Big vs Little Endian、网络字节顺序、分组化、会话信息等。

这取决于字符串的编码（ASCII、UTF-8…）。

例如：

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（…）。

有关详细信息，请参阅.NET Framework（MSDN）中的字符编码。

以下是我的String-to-Byte[]转换的不安全实现：

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，此方法也可以用作字符串扩展：

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

最快的方式

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

编辑正如Makotosan所说，这是现在最好的方式：

Encoding.UTF8.GetBytes(text)

试试这个，代码更少：

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

嗯，我读过所有的答案，它们都是关于使用编码或关于删除未配对代理的序列化。

例如，如果字符串来自SQL Server，它是从存储例如密码哈希的字节数组构建的，这就很糟糕了。如果我们从中删除任何内容，它将存储一个无效的哈希，如果我们想将其存储在XML中，我们希望保持它的完整性（因为XML编写器会在它找到的任何未配对代理上删除一个异常）。

所以我在这种情况下使用了字节数组的Base64编码，但是在互联网上，只有一种解决方案是C#，而且它有bug，而且只有一种方法，所以我已经修复了bug并编写了返回过程。给你，未来的谷歌人：

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