关于序列化的问题

Question

 public byte[] getDataSetSer()
    {
        DataSet ds = getDataSet(); 
        BinaryFormatter bf = new BinaryFormatter();
        MemoryStream ms = new MemoryStream();
        bf.Serialize(ms, ds);
        ms.Close();
        return ms.ToArray();
    }
代码如上，我的问题是ms.Close() 流已经关闭了 为什么用return ms.ToArray()返回还能得到正确的结果。
不太理解。第二个问题：
 byte[] data;
 (1) MemoryStream ms1 = new MemoryStream(data);
 (2) MemoryStream ms2 = new MemoryStream();
      ms2.Write(data, 0, data.Length);
  (1)和(2)的代码是等效的吗。
 因为每次解压缩时都要用到此段代码，如
  private byte[] myDeCompress(byte[] data)
        {
            MemoryStream input = new MemoryStream();
            input.Write(data, 0, data.Length);
            input.Position = 0;
            GZipStream gstream = new GZipStream(input, CompressionMode.Decompress, true);
            ........
        }
本人对流这方面实在有些迷糊 请高手指点！ 谢谢！

Answer 1

第一个问题：
下面是MemoryStream的几个方法的源代码：
public virtual byte[] ToArray()
{
    byte[] dst = new byte[this._length - this._origin];
    Buffer.InternalBlockCopy(this._buffer, this._origin, dst, 0, this._length - this._origin);
    return dst;
} 
protected override void Dispose(bool disposing)
{
    try
    {
        if (disposing)
        {
            this._isOpen = false;
            this._writable = false;
            this._expandable = false;
        }
    }
    finally
    {
        base.Dispose(disposing);
    }
}MemoryStream 没有定义自己的Close方法，而Base的Close就是调用Dispose（true）
你可以看到Close 并没有去清掉_buffer，所以ToArray的时候能返回数组第二个问题：
应该是等效的，只是用第二种方式要多几行代码了，Write后要把Postion归0

Answer 2

public MemoryStream(byte[] buffer, bool writable)
{
    if (buffer == null)
    {
        throw new ArgumentNullException("buffer", Environment.GetResourceString("ArgumentNull_Buffer"));
    }
    this._buffer = buffer;
    this._length = this._capacity = buffer.Length;
    this._writable = writable;
    this._exposable = false;
    this._origin = 0;
    this._isOpen = true;
} 
public override void Write(byte[] buffer, int offset, int count)
{
    if (!this._isOpen)
    {
        __Error.StreamIsClosed();
    }
    if (!this._writable)
    {
        __Error.WriteNotSupported();
    }
    if (buffer == null)
    {
        throw new ArgumentNullException("buffer", Environment.GetResourceString("ArgumentNull_Buffer"));
    }
    if (offset < 0)
    {
        throw new ArgumentOutOfRangeException("offset", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
    }
    if (count < 0)
    {
        throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
    }
    if ((buffer.Length - offset) < count)
    {
        throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
    }
    int num = this._position + count;
    if (num < 0)
    {
        throw new IOException(Environment.GetResourceString("IO.IO_StreamTooLong"));
    }
    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)
    {
        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;
}
Write只是在原来的基础上继续向_buffer添加byte【】，而实例化传入byte【】，就是初始化_buffer而已

Answer 3

1.MSDN的说明:MemoryStream.Close():Closes the stream for reading and writing.仅仅是关闭对流的读写，并没有清空流，流中的数据仍然存在。
2.效果是一样的。

Answer 4

第一个问题 二楼正解
第二个问题 两者不一样...Position属性不同 ^_^ 用ReadObject的时候 如果用byte[]初始化可以直接用 Write之后必须把Postion置0

Answer 5

1MemortStream使用用Close好象没用
2一样的效果 但感觉MemoryStream ms1 = new MemoryStream(data); 好看些

Answer 6

sorry  =我提交后 所有的回复都出来了