以下是我的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
    }
}

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

最快的方式

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

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

Encoding.UTF8.GetBytes(text)

OP的问题：“如何在.NET（C#）中将字符串转换为字节数组？”

您可以使用以下代码：

static byte[] ConvertString (string s) {
    return new byte[0];
}

作为一个好处，编码无关紧要！哦，等等，这是一个ecoding。。。它只是微不足道的，而且损耗很大。

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

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

将其转换回去应该是一件不容易的事，因为这意味着您实际上正在以某种方式解释数据，但为了完整性：

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

NonPortableCast和DangerousGetPinnableReference这两个名称应该进一步证明您可能不应该这样做。

注意，使用Span<T>需要安装System.Memory NuGet包。

无论如何，实际的原始问题和后续评论暗示底层内存没有被“解释”（我假设这意味着没有修改或读取，超出了按原样编写的需要），这表明应该使用Stream类的某些实现，而不是将数据作为字符串进行推理。

如果您使用的是.NET Core或System.Memory for.NET Framework，则通过Span＜T＞和Memory＜T＞有一种非常有效的封送机制，可以有效地将字符串内存重新解释为字节跨度。一旦有了一个字节跨度，就可以自由地封送回另一个类型，或者将该跨度复制到数组中进行序列化。

总结一下其他人的看法：

存储这种序列化的表示形式对系统端序、编译器优化以及正在执行的.NET运行时中字符串的内部表示形式的更改非常敏感。避免长期储存避免在其他环境中反序列化或解释字符串这包括其他机器、处理器体系结构、.NET运行时、容器等。这包括比较、格式化、加密、字符串操作、本地化、字符转换等。避免对字符编码进行假设在实践中，默认编码倾向于UTF-16LE，但编译器/运行时可以选择任何内部表示

实施

public static class MarshalExtensions
{
   public static ReadOnlySpan<byte> AsBytes(this string value) => MemoryMarshal.AsBytes(value.AsSpan());
   public static string AsString(this ReadOnlySpan<byte> value) => new string(MemoryMarshal.Cast<byte, char>(value));
}

实例

static void Main(string[] args)
{
    string str1 = "你好，世界";
    ReadOnlySpan<byte> span = str1.AsBytes();
    string str2 = span.AsString();

    byte[] bytes = span.ToArray();

    Debug.Assert(bytes.Length > 0);
    Debug.Assert(str1 == str2);
}

Furthur洞察

在C++中，这大致相当于reinterpret_cast，而C大致相当于对系统的单词类型（char）的强制转换。

在最新版本的.NET核心运行时（CoreCLR）中，如果您的内存是由CLR分配的，并且跨段不是从非托管内存分配器的指针派生的，则跨段上的操作可以有效地调用编译器内部函数和各种优化，这些优化有时可以消除边界检查，从而在保持内存安全的同时提高性能。

注意事项

这使用CLR支持的机制，该机制从字符串返回ReadOnlyPan<char>；此外，此跨度不一定包含完整的内部字符串布局。ReadOnlySpan＜T＞意味着如果需要执行变异，必须创建一个副本，因为字符串是不可变的。