CryptoStream 可以让基本流保持打开状态吗？

Question

我创建了一个MemoryStream，将其传递给CryptoStream 进行编写。我希望CryptoStream 加密，并让MemoryStream 对我开放，然后再读入其他内容。但是一旦CryptoStream 被处理，它也会处理MemoryStream。

CryptoStream 可以让基地MemoryStream 以某种方式打开吗？

using (MemoryStream scratch = new MemoryStream())
{
    using (AesManaged aes = new AesManaged())
    {
        // <snip>
        // Set some aes parameters, including Key, IV, etc.
        // </snip>
        ICryptoTransform encryptor = aes.CreateEncryptor();
        using (CryptoStream myCryptoStream = new CryptoStream(scratch, encryptor, CryptoStreamMode.Write))
        {
            myCryptoStream.Write(someByteArray, 0, someByteArray.Length);
        }
    }
    // Here, I'm still within the MemoryStream block, so I expect
    // MemoryStream to still be usable.
    scratch.Position = 0;    // Throws ObjectDisposedException
    byte[] scratchBytes = new byte[scratch.Length];
    scratch.Read(scratchBytes,0,scratchBytes.Length);
    return Convert.ToBase64String(scratchBytes);
}

Answer 1

从 .NET 4.7.2 开始，有第二个构造函数，其中添加了一个名为 leaveOpen 的 bool 参数。如果设置为 true，则CryptoStream 的 dispose 方法将不会在底层流上调用 dispose。

Additionally，另一个没有leaveOpen参数的构造函数只是将参数转发给leaveOpen设置为false的新构造函数。

MSDN
CryptoStream.Dispose(bool disposing)

Answer 2

作为第二种解决方案，您可以创建一个 WrapperStream 对象，该对象仅传递除 Dispose / Close 之外的每个调用。围绕您的内存流制作一个包装器，将包装器交给加密流，现在关闭加密流不会触及内存流。

Answer 3

您可以使用 using 语句，但不能使用。您将需要手动管理对象的处置，还需要调用FlushFinialBlock() 以确保在处理之前将所有数据写入底层流。

一旦你完成了对流的处理，你就可以在最后的 finally 块中释放你等待的所有资源。

MemoryStream scratch = null;
AesManaged aes = null;
CryptoStream myCryptoStream = null;
try
{
    scratch = new MemoryStream();
    aes = new AesManaged();

    // <snip>
    // Set some aes parameters, including Key, IV, etc.
    // </snip>
    ICryptoTransform encryptor = aes.CreateEncryptor();
    myCryptoStream = new CryptoStream(scratch, encryptor, CryptoStreamMode.Write);
    myCryptoStream.Write(someByteArray, 0, someByteArray.Length);

    //Flush the data out so it is fully written to the underlying stream.
    myCryptoStream.FlushFinalBlock();

    scratch.Position = 0; 
    byte[] scratchBytes = new byte[scratch.Length];
    scratch.Read(scratchBytes,0,scratchBytes.Length);
    return Convert.ToBase64String(scratchBytes);
}
finally
{
    //Dispose all of the disposeable objects we created in reverse order.

    if(myCryptoStream != null)
        myCryptoStream.Dispose();

    if(aes != null)
        aes.Dispose();

    if(scratch != null)
        scratch.Dispose();
}

Answer 4

我的简单解决方案：

class NotClosingCryptoStream : CryptoStream
{
    public NotClosingCryptoStream( Stream stream, ICryptoTransform transform, CryptoStreamMode mode )
        : base( stream, transform, mode )
    {
    }

    protected override void Dispose( bool disposing )
    {
        if( !HasFlushedFinalBlock )
            FlushFinalBlock();

        base.Dispose( false );
    }
}

Answer 5

事实证明，没有任何必要将 using {} 块拆分为 try{}finally{} ...最终，您只需在 using 语句中使用 FlushFinalBlock() 并嵌套其他任何内容根据需要在里面。

using (MemoryStream scratch = new MemoryStream())
{
    using (AesManaged aes = new AesManaged())
    {
        // <snip>
        // Set some aes parameters, including Key, IV, etc.
        // </snip>
        ICryptoTransform encryptor = aes.CreateEncryptor();
        using (CryptoStream myCryptoStream = new CryptoStream(scratch, encryptor, CryptoStreamMode.Write))
        {
            myCryptoStream.Write(someByteArray, 0, someByteArray.Length);
            myCryptoStream.FlushFinalBlock();
            scratch.Flush();   // not sure if this is necessary
            byte[] scratchBytes = scratch.ToArray();
            return Convert.ToBase64String(scratchBytes);
        }
    }
}