关于MemoryStream类

许多人认为MemoryStream是无法进行扩展的，其实不然；为了更好了解MemoryStream，我不得不研究MemoryStream的源代码，首先看空构造函数（以下代码均是Reflector Pro版本反射得到）：

[C#]

public MemoryStream() : this(0)
{
}

public MemoryStream(int capacity)
{
    if (capacity < 0)
    {
        throw new ArgumentOutOfRangeException("capacity", Environment.GetResourceString("ArgumentOutOfRange_NegativeCapacity"));
    }
    this._buffer = new byte[capacity];
    this._capacity = capacity;
    this._expandable = true;
    this._writable = true;
    this._exposable = true;
    this._origin = 0;
    this._isOpen = true;
}

[VB.NET]

Public Sub New()
    Me.New(0)
End Sub

Public Sub New(ByVal capacity As Integer)
    If (capacity < 0) Then
        Throw New ArgumentOutOfRangeException("capacity", Environment.GetResourceString("ArgumentOutOfRange_NegativeCapacity"))
    End If
    Me._buffer = New Byte(capacity  - 1) {}
    Me._capacity = capacity
    Me._expandable = True
    Me._writable = True
    Me._exposable = True
    Me._origin = 0
    Me._isOpen = True
End Sub

从代码中可以知道——MemoryStream内部存放的一个内存数组，当空构造函数的时候，该数组的实际容量为0；然后调用Write函数的时候……

[C#]

public override void Write(byte[] buffer, int offset, int count)
{
    //省去其它部分……

    int num = this._position + count;

    if (num > this._length)
    {
        bool flag = this._position > this._length;
        if ((num > this._capacity) && this.EnsureCapacity(num))
        {
            flag = false;
        }
        if (flag)
        {
            Array.Clear(this._buffer, this._length, num - this._length);
        }
        this._length = num;
    }
    if ((count <= 8) && (buffer != this._buffer))
    {
        int num2 = count;
        while (--num2 >= 0)
        {
            this._buffer[this._position + num2] = buffer[offset + num2];
        }
    }
    else
    {
        Buffer.InternalBlockCopy(buffer, offset, this._buffer, this._position, count);
    }
    this._position = num;
}

[VB.NET]

Public Overrides Sub Write(buffer__1 As Byte(), offset As Integer, count As Integer)
    '省去其它部分……

Dim num As Integer = (Me._position + count)

    If num > Me._length Then
        Dim flag As Boolean = Me._position > Me._length
        If (num > Me._capacity) AndAlso Me.EnsureCapacity(num) Then
            flag = False
        End If
        If flag Then
            Array.Clear(Me._buffer, Me._length, num - Me._length)
        End If
        Me._length = num
    End If
    If (count <= 8) AndAlso (buffer<> Me._buffer) Then
        Dim num2 As Integer = count

        Do While (--num2 >= 0)
            Me._buffer((Me._position + num2)) = buffer((offset + num2))
        Loop

    Else
        Buffer.InternalBlockCopy(buffer__1, offset, Me._buffer, Me._position, count)
    End If
    Me._position = num
End Sub

以上代码大致的意思是：先检测内部剩余空间是否足够容纳外部buffer要写入的字节数（count），如果探测发现内部数组剩余空间不够的话，那么自动扩容——请注意EnsureCapacity函数，反编译结果如下：
[C#]

private bool EnsureCapacity(int value)
{
    if (value < 0)
    {
        throw new IOException(Environment.GetResourceString("IO.IO_StreamTooLong"));
    }
    if (value <= this._capacity)
    {
        return false;
    }
    int num = value;
    if (num < 0x100)
    {
        num = 0x100;
    }
    if (num < (this._capacity * 2))
    {
        num = this._capacity * 2;
    }
    this.Capacity = num;
    return true;
}

[VB.NET]

从反编译结果可以明显看到，MemoryStream在使用第一、第二构造函数的时候（指定capability的时候，非直接传入一个byte数组的时候）是可以进行扩容的。扩容情况如下：

1）当实际需要的容量小于256个字节，自动扩容到256；

2）当实际需要的容量小于实际容量的2倍的时候，自动扩容到自身容量的2倍。

而真正扩容的地方在属性Capacity中——

[C#]

public virtual int Capacity
{
    //省略其它部分……
        if (this._expandable && (value != this._capacity))
        {
            if (value > 0)
            {
                byte[] dst = new byte[value];
                if (this._length > 0)
                {
                    Buffer.InternalBlockCopy(this._buffer, 0, dst, 0, this._length);
                }
                this._buffer = dst;
            }
            else
            {
                this._buffer = null;
            }
            this._capacity = value;
        }
    }
}

[VB.NET]

Public Overridable Property Capacity As Integer
   '省略其它部分……

        If (Me._expandable AndAlso (value <> Me._capacity)) Then
            If (value > 0) Then
                Dim dst As Byte() = New Byte(value  - 1) {}
                If (Me._length > 0) Then
                    Buffer.InternalBlockCopy(Me._buffer, 0, dst, 0, Me._length)
                End If
                Me._buffer = dst
            Else
                Me._buffer = Nothing
            End If
            Me._capacity = value
        End If
    End Set
End Property

可见，.NET类库做的是“先生成新数组，然后使用内部底层的InteralBlockCopy进行批量拷贝。不过请注意————expandable是一个条件，该条件决定MemoryStream是否允许扩容，而这个私有变量在MemoryStream上面给出的两个构造函数中充分显示了。因此只有在使用MemoryStream的第一、二构造函数的时候才允许扩容，其余时候都是不允许的（因为默认expandable=false，布尔值默认是false）。