如何在.NET中高效地使用流包装字符串？

Question

关于将字符串转换为流的问题很常见，例如：

• 将字符串转换为流
• 如何从字符串生成流？
• 将字符串转换为System.IO.Stream

还有很多其他类似的问题。

然而，我还没有看到一个不会复制原始字符串占用内存的实现。最简单的建议是将字符串转换为字节并从中初始化一个MemoryStream。

另一个建议是将其写入包装在MemoryStream中的StreamWriter。

所有这些方法都不是内存高效的。

我提出这个问题的原因是我必须处理一个遗留系统，这个系统由于愚蠢而产生了一个巨大的字符串。现在我需要对这个字符串进行某些后处理，并将其写入文件，但我不想复制这个可恶的东西。因此，我正在寻找一种内存高效的方法来解决这个问题。

- mark

---

你需要流支持哪些操作？仅仅是Read还是你也需要Seek？我猜想不需要Write（所以我对你的问题中建议使用StreamWriter感到惊讶），因为字符串是不可变的。 - Damien_The_Unbeliever

只读取。我更喜欢使用“Stream”，因为它更适合二进制转换。 - mark

为什么不使用String.SubString重复提取合理大小的字符串部分，并进行后处理呢？ - Joe

给那位点踩的人 - 能否理性解释一下？ - mark

编码怎么样？我的意思是，字符串可以以许多不同的方式转换为字节（因此流）。 - Ivan Stoev

Answer 1

编写自定义的Stream派生类并不难，但在这种情况下具有挑战性的部分是需要Encoding支持。以下是只读前向实现，当需要时使用小缓冲区适合一个完整的字符字节：

public static class StringUtils
{
    public static Stream AsStream(this string source, Encoding encoding = null)
    {
        return string.IsNullOrEmpty(source) ? Stream.Null : new StringStream(source, encoding ?? Encoding.UTF8);
    }

    class StringStream : Stream
    {
        string source;
        Encoding encoding;
        int position, length;
        int charPosition;
        int maxBytesPerChar;
        byte[] encodeBuffer;
        int encodeOffset, encodeCount;

        internal StringStream(string source, Encoding encoding)
        {
            this.source = source;
            this.encoding = encoding;
            length = encoding.GetByteCount(source);
            maxBytesPerChar = encoding.GetMaxByteCount(1);
        }

        public override bool CanRead { get { return true; } }
        public override bool CanSeek { get { return false; } }
        public override bool CanWrite { get { return false; } }
        public override long Length { get { return length; } }
        public override void SetLength(long value) { throw new NotSupportedException(); }
        public override long Position { get { return position; } set { throw new NotSupportedException(); } }
        public override long Seek(long offset, SeekOrigin origin) { throw new NotSupportedException(); }
        public override void Write(byte[] buffer, int offset, int count) { throw new NotSupportedException(); }
        public override void Flush() { }
        public override int Read(byte[] buffer, int offset, int count)
        {
            int readCount = 0;
            for (int byteCount; readCount < count && position < length; position += byteCount, readCount += byteCount)
            {
                if (encodeCount == 0)
                {
                    int charCount = Math.Min((count - readCount) / maxBytesPerChar, source.Length - charPosition);
                    if (charCount > 0)
                    {
                        byteCount = encoding.GetBytes(source, charPosition, charCount, buffer, offset + readCount);
                        Debug.Assert(byteCount > 0 && byteCount <= (count - readCount));
                        charPosition += charCount;
                        continue;
                    }
                    if (encodeBuffer == null) encodeBuffer = new byte[maxBytesPerChar];
                    encodeCount = encoding.GetBytes(source, charPosition, 1, encodeBuffer, encodeOffset = 0);
                    Debug.Assert(encodeCount > 0);
                }
                byteCount = Math.Min(encodeCount, count - readCount);
                for (int i = 0; i < byteCount; i++)
                    buffer[offset + readCount + i] = encodeBuffer[encodeOffset + i];
                encodeOffset += byteCount;
                if ((encodeCount -= byteCount) == 0) charPosition++;
            }
            return readCount;
        }
    }
}

- Ivan Stoev