另一个解决方案:

public static MemoryStream GenerateStreamFromString(string value)
{
    return new MemoryStream(Encoding.UTF8.GetBytes(value ?? ""));
}

String扩展的良好组合:

public static byte[] GetBytes(this string str)
{
    byte[] bytes = new byte[str.Length * sizeof(char)];
    System.Buffer.BlockCopy(str.ToCharArray(), 0, bytes, 0, bytes.Length);
    return bytes;
}

public static Stream ToStream(this string str)
{
    Stream StringStream = new MemoryStream();
    StringStream.Read(str.GetBytes(), 0, str.Length);
    return StringStream;
}

public static Stream GenerateStreamFromString(string s)
{
    var stream = new MemoryStream();
    var writer = new StreamWriter(stream);
    writer.Write(s);
    writer.Flush();
    stream.Position = 0;
    return stream;
}

不要忘记使用Using:

using (var stream = GenerateStreamFromString("a,b \n c,d"))
{
    // ... Do stuff to stream
}

关于StreamWriter没有被处理。StreamWriter只是一个基本流的包装器，不使用任何需要被处理的资源。Dispose方法将关闭StreamWriter写入的底层流。在本例中，这就是我们想要返回的MemoryStream。

在。net 4.5中，现在有一个StreamWriter的重载，它在写入器被处理后保持底层流打开，但是这段代码做同样的事情，也适用于其他版本的。net。

是否有办法关闭一个StreamWriter而不关闭它的BaseStream?

如果你需要改变编码，我投票给@ShaunBowe的解决方案。但是这里的每个答案都至少将整个字符串复制到内存中一次。ToCharArray + BlockCopy组合的答案做了两次。

如果这很重要的话，这里有一个用于原始UTF-16字符串的简单流包装器。如果与StreamReader一起使用，请选择Encoding。Unicode:

public class StringStream : Stream
{
    private readonly string str;

    public override bool CanRead => true;
    public override bool CanSeek => true;
    public override bool CanWrite => false;
    public override long Length => str.Length * 2;
    public override long Position { get; set; } // TODO: bounds check

    public StringStream(string s) => str = s ?? throw new ArgumentNullException(nameof(s));

    public override long Seek(long offset, SeekOrigin origin)
    {
        switch (origin)
        {
            case SeekOrigin.Begin:
                Position = offset;
                break;
            case SeekOrigin.Current:
                Position += offset;
                break;
            case SeekOrigin.End:
                Position = Length - offset;
                break;
        }

        return Position;
    }

    private byte this[int i] => (i & 1) == 0 ? (byte)(str[i / 2] & 0xFF) : (byte)(str[i / 2] >> 8);

    public override int Read(byte[] buffer, int offset, int count)
    {
        // TODO: bounds check
        var len = Math.Min(count, Length - Position);
        for (int i = 0; i < len; i++)
            buffer[offset++] = this[(int)(Position++)];
        return (int)len;
    }

    public override int ReadByte() => Position >= Length ? -1 : this[(int)Position++];
    public override void Flush() { }
    public override void SetLength(long value) => throw new NotSupportedException();
    public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException();
    public override string ToString() => str; // ;)     
}

这里有一个更完整的解决方案，包含必要的绑定检查(派生自MemoryStream，因此它也有ToArray和WriteTo方法)。

使用MemoryStream类，调用Encoding。GetBytes首先将字符串转换为字节数组。

您随后是否需要流上的TextReader ?如果是这样，您可以直接提供一个StringReader，并绕过MemoryStream和Encoding步骤。

我使用了如下的混合答案:

public static Stream ToStream(this string str, Encoding enc = null)
{
    enc = enc ?? Encoding.UTF8;
    return new MemoryStream(enc.GetBytes(str ?? ""));
}

然后我这样使用它:

String someStr="This is a Test";
Encoding enc = getEncodingFromSomeWhere();
using (Stream stream = someStr.ToStream(enc))
{
    // Do something with the stream....
}