[C#]MemoryStream.Dispose之后，為什么仍可以ToArray()?

目錄

概述

MemoryStream分析

總結

概述

事件起因，一哥們在群里面貼出了類似下面這樣的一段代碼：

    class Program
    {
        static void Main(string[] args)
        {
            byte[] buffer = File.ReadAllBytes("test.txt");     
            MemoryStream ms = new MemoryStream(buffer);
            ms.Dispose();
            Console.WriteLine(ms.ToArray().Length);
            Console.Read();
        }
    }

先不去考究這段代碼到底有沒有什么意義，就代碼而言，內存流釋放之后，再去使用ms會有問題么？

運行結果：

在印象中非托管資源Dispose之后，應該會出現“無法訪問已釋放的資源”之類的異常吧，但是你真正的運行的時候，你會發現並沒有錯。真的怪了，沒辦法，出於好奇也就研究了一下。

那我們如果訪問ms對象的其他的屬性（ms.Length）會怎么樣呢？

訪問其它的方法它也會出現上面的異常。

這問題出來了，難道內存流的Dispose方法是選擇性的釋放？

在看MemoryStream分析之前，回顧一下托管與非托管資源的概念。

托管資源

一般是指被CLR控制的內存資源，這些資源的管理可以由CLR來控制，例如程序中分配(new)的對象，作用域內的變量等。

非托管資源

是CLR不能控制或者管理的部分，這些資源有很多，比如文件流，數據庫的連接，系統的窗口句柄(Window內核對象（句柄）)、字體、刷子、dc打印機資源等等……這些資源一般情況下不存在於Heap（內存中用於存儲對象實例的地方）中。

C#的垃圾回收器：
    CLR為程序員提供的內存管理機制，使得程序員在編寫代碼時不需要顯式的去釋放自己使用的內存資源（這些在先前C和C++中是需要程序員自己去顯式的釋放的）。這種管理機制稱為GC(garbage collection)。GC的作用是很明顯的，當系統內存資源匱乏時，它就會被激發，然后自動的去釋放那些沒有被使用的托管資源（也就是程序員沒有顯式釋放的對象）。對於那些非托管資源雖然垃圾回收器可以跟蹤封裝非托管資源的對象的生存期,但它不了解具體如何清理這些資源。還好.net提供了Finalize()方法，它允許在垃圾回收器回收該類資源時，適當的清理非托管資源。但是Finalize()會產生很多副作用。

釋放非托管資源 

資源的釋放一般是通過"垃圾回收器"自動完成的,但具體來說,仍有些需要注意的地方：
　　1、值類型和引用類型的引用其實是不需要什么"垃圾回收器"來釋放內存的,因為當它們出了作用域后會自動釋放所占內存，因為它們都保存在棧(Stack)中;
　　2、只有引用類型的引用所指向的對象實例才保存在堆(Heap)中,而堆因為是一個自由存儲空間,所以它並沒有像"棧"那樣有生存期("棧"的元素彈出后就代表生存期結束,也就代表釋放了內存),並且要注意的是,"垃圾回收器"只對這塊區域起作用。
    然而,有些情況下，當需要釋放非托管資源時,就必須通過寫代碼的方式來解決。

非托管資源的釋放

當我們在類中封裝了對非托管資源的操作時，我們就需要顯式釋放(Dispose)，或隱式釋放(Finalize)的釋放這些資源。
Finalize一般情況下用於基類不帶close方法或者不帶Dispose顯式方法的類，也就是說，在Finalize過程中我們需要隱式的去實現非托管資源的釋放，然后系統會在Finalize過程完成后，自己的去釋放托管資源。如果要實現Dispose方法，可以通過實現IDisposable接口，這樣用戶在使用這個類的同時就可以顯示的執行Dispose方法，釋放資源。

 （詳細的內容可參考：http://blog.csdn.net/xiven/article/details/4951099）

 

MemoryStream分析

對於這個問題，吃飯的時候一直很糾結，所以就查了一些這方面的資料，也試圖反編譯MemoryStream類，看看Dispose方法是如何實現。

 參考：

http://stackoverflow.com/questions/4274590/memorystream-close-or-memorystream-dispose

https://github.com/mono/mono/blob/137a5c40cfecff099f3b5e97c425663ed2e8505d/mcs/class/corlib/System.IO/MemoryStream.cs#L220

github上MemoryStream中的代碼：

//
// System.IO.MemoryStream.cs
//
// Authors:    Marcin Szczepanski ([e-mail])
//        Patrik Torstensson
//        Gonzalo Paniagua Javier ([e-mail])
//        Marek Safar ([e-mail])
//
// (c) 2001,2002 Marcin Szczepanski, Patrik Torstensson
// (c) 2003 Ximian, Inc. (http://www.ximian.com)
// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
// Copyright 2011 Xamarin, Inc (http://www.xamarin.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

using System.Globalization;
using System.Runtime.InteropServices;
using System.Threading;
#if NET_4_5
using System.Threading.Tasks;
#endif

namespace System.IO
{
    [Serializable]
    [ComVisible (true)]
    [MonoLimitation ("Serialization format not compatible with .NET")]
    public class MemoryStream : Stream
    {
        bool canWrite;
        bool allowGetBuffer;
        int capacity;
        int length;
        byte [] internalBuffer;
        int initialIndex;
        bool expandable;
        bool streamClosed;
        int position;
        int dirty_bytes;
#if NET_4_5
        [NonSerialized]
        Task<int> read_task;
#endif

        public MemoryStream () : this (0)
        {
        }

        public MemoryStream (int capacity)
        {
            if (capacity < 0)
                throw new ArgumentOutOfRangeException ("capacity");

            canWrite = true;

            this.capacity = capacity;
            internalBuffer = new byte [capacity];

            expandable = true;
            allowGetBuffer = true;
        }

        public MemoryStream (byte [] buffer)
        {
            if (buffer == null)
                throw new ArgumentNullException ("buffer");
            
            InternalConstructor (buffer, 0, buffer.Length, true, false);                        
        }

        public MemoryStream (byte [] buffer, bool writable)
        {
            if (buffer == null)
                throw new ArgumentNullException ("buffer");
            
            InternalConstructor (buffer, 0, buffer.Length, writable, false);
        }

        public MemoryStream (byte [] buffer, int index, int count)
        {
            InternalConstructor (buffer, index, count, true, false);
        }

        public MemoryStream (byte [] buffer, int index, int count, bool writable)
        {
            InternalConstructor (buffer, index, count, writable, false);
        }

        public MemoryStream (byte [] buffer, int index, int count, bool writable, bool publiclyVisible)
        {
            InternalConstructor (buffer, index, count, writable, publiclyVisible);
        }

        void InternalConstructor (byte [] buffer, int index, int count, bool writable, bool publicallyVisible)
        {
            if (buffer == null)
                throw new ArgumentNullException ("buffer");

            if (index < 0 || count < 0)
                throw new ArgumentOutOfRangeException ("index or count is less than 0.");

            if (buffer.Length - index < count)
                throw new ArgumentException ("index+count", 
                                 "The size of the buffer is less than index + count.");

            canWrite = writable;

            internalBuffer = buffer;
            capacity = count + index;
            length = capacity;
            position = index;
            initialIndex = index;

            allowGetBuffer = publicallyVisible;
            expandable = false;                
        }

        void CheckIfClosedThrowDisposed ()
        {
            if (streamClosed)
                throw new ObjectDisposedException ("MemoryStream");
        }
        
        public override bool CanRead {
            get { return !streamClosed; }
        }

        public override bool CanSeek {
            get { return !streamClosed; }
        }

        public override bool CanWrite {
            get { return (!streamClosed && canWrite); }
        }

        public virtual int Capacity {
            get {
                CheckIfClosedThrowDisposed ();
                return capacity - initialIndex;
            }

            set {
                CheckIfClosedThrowDisposed ();

                if (!expandable)
                    throw new NotSupportedException ("Cannot expand this MemoryStream");

                if (value < 0 || value < length)
                    throw new ArgumentOutOfRangeException ("value",
                    "New capacity cannot be negative or less than the current capacity " + value + " " + capacity);

                if (internalBuffer != null && value == internalBuffer.Length)
                    return;

                byte [] newBuffer = null;
                if (value != 0) {
                    newBuffer = new byte [value];
                    if (internalBuffer != null)
                        Buffer.BlockCopy (internalBuffer, 0, newBuffer, 0, length);
                }

                dirty_bytes = 0; // discard any dirty area beyond previous length
                internalBuffer = newBuffer; // It's null when capacity is set to 0
                capacity = value;
            }
        }

        public override long Length {
            get {
                // LAMESPEC: The spec says to throw an IOException if the
                // stream is closed and an ObjectDisposedException if
                // "methods were called after the stream was closed".  What
                // is the difference?

                CheckIfClosedThrowDisposed ();

                // This is ok for MemoryStreamTest.ConstructorFive
                return length - initialIndex;
            }
        }

        public override long Position {
            get {
                CheckIfClosedThrowDisposed ();
                return position - initialIndex;
            }

            set {
                CheckIfClosedThrowDisposed ();
                if (value < 0)
                    throw new ArgumentOutOfRangeException ("value",
                                "Position cannot be negative" );

                if (value > Int32.MaxValue)
                    throw new ArgumentOutOfRangeException ("value",
                    "Position must be non-negative and less than 2^31 - 1 - origin");

                position = initialIndex + (int) value;
            }
        }

        protected override void Dispose (bool disposing)
        {
            streamClosed = true;
            expandable = false;
        }

        public override void Flush ()
        {
            // Do nothing
        }

        public virtual byte [] GetBuffer ()
        {
            if (!allowGetBuffer)
                throw new UnauthorizedAccessException ();

            return internalBuffer;
        }

        public override int Read ([In,Out] byte [] buffer, int offset, int count)
        {
            if (buffer == null)
                throw new ArgumentNullException ("buffer");

            if (offset < 0 || count < 0)
                throw new ArgumentOutOfRangeException ("offset or count less than zero.");

            if (buffer.Length - offset < count )
                throw new ArgumentException ("offset+count",
                                  "The size of the buffer is less than offset + count.");

            CheckIfClosedThrowDisposed ();

            if (position >= length || count == 0)
                return 0;

            if (position > length - count)
                count = length - position;

            Buffer.BlockCopy (internalBuffer, position, buffer, offset, count);
            position += count;
            return count;
        }

        public override int ReadByte ()
        {
            CheckIfClosedThrowDisposed ();
            if (position >= length)
                return -1;

            return internalBuffer [position++];
        }

        public override long Seek (long offset, SeekOrigin loc)
        {
            CheckIfClosedThrowDisposed ();

            // It's funny that they don't throw this exception for < Int32.MinValue
            if (offset > (long) Int32.MaxValue)
                throw new ArgumentOutOfRangeException ("Offset out of range. " + offset);

            int refPoint;
            switch (loc) {
            case SeekOrigin.Begin:
                if (offset < 0)
                    throw new IOException ("Attempted to seek before start of MemoryStream.");
                refPoint = initialIndex;
                break;
            case SeekOrigin.Current:
                refPoint = position;
                break;
            case SeekOrigin.End:
                refPoint = length;
                break;
            default:
                throw new ArgumentException ("loc", "Invalid SeekOrigin");
            }

            // LAMESPEC: My goodness, how may LAMESPECs are there in this
            // class! :)  In the spec for the Position property it's stated
            // "The position must not be more than one byte beyond the end of the stream."
            // In the spec for seek it says "Seeking to any location beyond the length of the 
            // stream is supported."  That's a contradiction i'd say.
            // I guess seek can go anywhere but if you use position it may get moved back.

            refPoint += (int) offset;
            if (refPoint < initialIndex)
                throw new IOException ("Attempted to seek before start of MemoryStream.");

            position = refPoint;
            return position;
        }

        int CalculateNewCapacity (int minimum)
        {
            if (minimum < 256)
                minimum = 256; // See GetBufferTwo test

            if (minimum < capacity * 2)
                minimum = capacity * 2;

            return minimum;
        }

        void Expand (int newSize)
        {
            // We don't need to take into account the dirty bytes when incrementing the
            // Capacity, as changing it will only preserve the valid clear region.
            if (newSize > capacity)
                Capacity = CalculateNewCapacity (newSize);
            else if (dirty_bytes > 0) {
                Array.Clear (internalBuffer, length, dirty_bytes);
                dirty_bytes = 0;
            }
        }

        public override void SetLength (long value)
        {
            if (!expandable && value > capacity)
                throw new NotSupportedException ("Expanding this MemoryStream is not supported");

            CheckIfClosedThrowDisposed ();

            if (!canWrite) {
                throw new NotSupportedException (Locale.GetText 
                    ("Cannot write to this MemoryStream"));
            }

            // LAMESPEC: AGAIN! It says to throw this exception if value is
            // greater than "the maximum length of the MemoryStream".  I haven't
            // seen anywhere mention what the maximum length of a MemoryStream is and
            // since we're this far this memory stream is expandable.
            if (value < 0 || (value + initialIndex) > (long) Int32.MaxValue)
                throw new ArgumentOutOfRangeException ();

            int newSize = (int) value + initialIndex;

            if (newSize > length)
                Expand (newSize);
            else if (newSize < length) // Postpone the call to Array.Clear till expand time
                dirty_bytes += length - newSize;

            length = newSize;
            if (position > length)
                position = length;
        }

        public virtual byte [] ToArray ()
        {
            int l = length - initialIndex;
            byte[] outBuffer = new byte [l];

            if (internalBuffer != null)
                Buffer.BlockCopy (internalBuffer, initialIndex, outBuffer, 0, l);
            return outBuffer; 
        }

        public override void Write (byte [] buffer, int offset, int count)
        {
            if (buffer == null)
                throw new ArgumentNullException ("buffer");
            
            if (offset < 0 || count < 0)
                throw new ArgumentOutOfRangeException ();

            if (buffer.Length - offset < count)
                throw new ArgumentException ("offset+count",
                                 "The size of the buffer is less than offset + count.");

            CheckIfClosedThrowDisposed ();

            if (!CanWrite)
                throw new NotSupportedException ("Cannot write to this stream.");

            // reordered to avoid possible integer overflow
            if (position > length - count)
                Expand (position + count);

            Buffer.BlockCopy (buffer, offset, internalBuffer, position, count);
            position += count;
            if (position >= length)
                length = position;
        }

        public override void WriteByte (byte value)
        {
            CheckIfClosedThrowDisposed ();
            if (!canWrite)
                throw new NotSupportedException ("Cannot write to this stream.");

            if (position >= length) {
                Expand (position + 1);
                length = position + 1;
            }

            internalBuffer [position++] = value;
        }

        public virtual void WriteTo (Stream stream)
        {
            CheckIfClosedThrowDisposed ();

            if (stream == null)
                throw new ArgumentNullException ("stream");

            stream.Write (internalBuffer, initialIndex, length - initialIndex);
        }

#if NET_4_5

        public override Task CopyToAsync (Stream destination, int bufferSize, CancellationToken cancellationToken)
        {
            // TODO: Specialization but what for?
            return base.CopyToAsync (destination, bufferSize, cancellationToken);
        }

        public override Task FlushAsync (CancellationToken cancellationToken)
        {
            if (cancellationToken.IsCancellationRequested)
                return TaskConstants.Canceled;

            try {
                Flush ();
                return TaskConstants.Finished;
            } catch (Exception ex) {
                return Task<object>.FromException (ex);
            }
        }

        public override Task<int> ReadAsync (byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            if (buffer == null)
                throw new ArgumentNullException ("buffer");

            if (offset < 0 || count < 0)
                throw new ArgumentOutOfRangeException ("offset or count less than zero.");

            if (buffer.Length - offset < count )
                throw new ArgumentException ("offset+count",
                                             "The size of the buffer is less than offset + count.");
            if (cancellationToken.IsCancellationRequested)
                return TaskConstants<int>.Canceled;

            try {
                count = Read (buffer, offset, count);

                // Try not to allocate a new task for every buffer read
                if (read_task == null || read_task.Result != count)
                    read_task = Task<int>.FromResult (count);

                return read_task;
            } catch (Exception ex) {
                return Task<int>.FromException (ex);
            }
        }

        public override Task WriteAsync (byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            if (buffer == null)
                throw new ArgumentNullException ("buffer");
            
            if (offset < 0 || count < 0)
                throw new ArgumentOutOfRangeException ();

            if (buffer.Length - offset < count)
                throw new ArgumentException ("offset+count",
                                             "The size of the buffer is less than offset + count.");

            if (cancellationToken.IsCancellationRequested)
                return TaskConstants.Canceled;

            try {
                Write (buffer, offset, count);
                return TaskConstants.Finished;
            } catch (Exception ex) {
                return Task<object>.FromException (ex);
            }
        }
#endif
    }               
}

通過上面的代碼，你可以看出，很多方法和屬性中都會有這樣的一個方法的調用：

CheckIfClosedThrowDisposed ();

該方法的實現

void CheckIfClosedThrowDisposed ()
    {
                      if (streamClosed)
        throw new ObjectDisposedException ("MemoryStream");
    }

通過方法名可以清楚的知道該方法的作用：檢查如果關閉了則拋出Dispose異常，通過方法體也可以清楚的知道該方法的作用。
你可以看一下ToArray方法

    public virtual byte [] ToArray ()
        {
            int l = length - initialIndex;
            byte[] outBuffer = new byte [l];

            if (internalBuffer != null)
                Buffer.BlockCopy (internalBuffer, initialIndex, outBuffer, 0, l);
            return outBuffer; 
        }

從代碼中，也可以看出該方法並沒有對流是否關閉進行檢查。

總結

雖然上面的代碼能說明為什么出現異常的原因，但是為什么要這樣設計？為什么其他的方法會檢測是否釋放而ToArray方法反而放過呢？

功底有限，也只能到這地步，如果哪個園友有更深入的解釋，可以給個合理的解釋，為什么這樣設計？

選擇性的釋放，那會不會就不安全了呢？