被MemoryStream狠狠地坑了一把

Stream是.net数据流操作的一个封装,它提供统一的流读写规则,为后期开发这方面的功能提供了很大的便利性.有些场景下是直接操作byte[]比较灵活所以Stream派生出MemoryStream从byte[]构建一个stream来方便开发人员使用.但在使用的时候碰到了一个非常坑爹事情.一个非常意想不到的结果...

应用代码

string value = "111111111";
            string value1 = "2222222222222222222222";
            System.IO.MemoryStream stream = new System.IO.MemoryStream(mBuffer);
            int count = Encoding.UTF8.GetBytes(value, 0, value.Length, mBuffer, 0);
            stream.Position = 0;
            stream.SetLength(count);
            Console.WriteLine("Length:"+count);
            Console.WriteLine(Encoding.UTF8.GetString(mBuffer, 0, count));

            count = Encoding.UTF8.GetBytes(value1, 0, value1.Length, mBuffer, 0);
            stream.Position = 0;
            stream.SetLength(count);
            Console.WriteLine("Length:" + count); ;
            Console.WriteLine(Encoding.UTF8.GetString(mBuffer, 0, count));
            Console.Read();

以上代码是把不同长度的字符编码到buffer中,然后再设置对应stream的开始位置和长度,从而让stream提供给其他功能使用,比较常见的就是对象反序列化等工作.从代码来看结果输出内容分别value和value1,但最终的运行结果确是

value1对应的内容少了一截...当出现这问题的时候排查了很久数据跟踪但没发现有任何环节有异常,因为buffer在后期根本没有地方对它进行修改,但数据确发生改变.

MemoryStream的一个坑

在跟踪日志来看buffer在经过stream.setlength之前都是好的,但经过这个方法后buffer内容就改变了,后面的代码也没对stream进行任何的操作;所以马上想到地扩容的问题,但由于buffer的长度比较大对应setlength的值也不可能大于buffer分配的长度问题应该不是扩容导致的;无耐之下只好反编译MomeryStream的代码看下,仔细查看MomeryStream的setlength后终于找到问题的根源...

int num = this._origin + (int)value;
	if (!this.EnsureCapacity(num) && num > this._length)
	{
		Array.Clear(this._buffer, this._length, num - this._length);
	}

这代码说明了一切问题,在setlength里如果没有导致扩容和大于之前的长度,则会增长部分进行一个清除操作...

实际应用中使用的代码

namespace MSMQNode.Agent
{
    public class ProtoBufFormater : IObjectFormater
    {
        public object Deserialize(ByteArraySegment content)
        {
            object result;
            try
            {
                content.SetPostion(0);
                string text = content.ReadShortString(Encoding.UTF8);
                Type type = Type.GetType(text);
                if (type == null)
                {
                    throw MQError.TYPE_NOTFOUND(text);
                }
                object obj = Activator.CreateInstance(type);
                Stream stream = content.GetStream();
                stream.Position = (long)content.Postion;
                stream.SetLength((long)content.Count);
                obj = RuntimeTypeModel.Default.Deserialize(stream, null, type);
                result = obj;
            }
            catch (Exception error)
            {
                throw new MQMessageFormatError("Deserialize Error!", error);
            }
            return result;
        }
        public ByteArraySegment Serialize(object message)
        {
            ByteArraySegment byteArraySegment = HttpDataPackage.BufferPool.Pop();
            try
            {
                Type type = message.GetType();
                string typeName = Utils.GetTypeName(type);
                byteArraySegment.WriteShortString(typeName, Encoding.UTF8);
                Stream stream = byteArraySegment.GetStream();
                stream.Position = (long)byteArraySegment.Postion;
                stream.SetLength((long)byteArraySegment.Postion);
                RuntimeTypeModel.Default.Serialize(stream, message);
                byteArraySegment.SetInfo(0, (int)stream.Length);
            }
            catch (Exception error)
            {
                HttpDataPackage.BufferPool.Push(byteArraySegment);
                throw new MQMessageFormatError("Serialize Error!", error);
            }
            return byteArraySegment;
        }
    }
}

解决方法

解决以上问题的办法有几种:

1)在每次使用的时候都针对buffer创建新的MemoryStream

2)由MemoryStream重新写入流数据

3)实现一个简单的Stream,调整一下SetLength代码

针对自己的情况选择第三种方式是最简单,代码调整范围小又能达到不重复创建Stream的目的.直接反编译MemoryStream抄一把:)

    public class ArraySegmentStream:System.IO.Stream
    {
        public ArraySegmentStream(byte[] data)
        {
            _buffer = data;
            _length = 0;
            _position = 0;
            _origin = 0;
        }

        private byte[] _buffer;

        private int _origin;

        private int _position;

        public override bool CanRead
        {
            get { return true; }
        }

        public override bool CanSeek
        {
            get { return true; }
        }

        public override bool CanWrite
        {
            get { return true; }
        }

        public override void Flush()
        {
            
        }

        private int _length = 0;

        public override long Length
        {
            get { return _length; }
        }

        public override long Position
        {
            get
            {
                return _position;
            }
            set
            {
                _position = (int)value;
            }
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            
            int num = this._length - this._position;
            if (num > count)
            {
                num = count;
            }
            if (num <= 0)
            {
                return 0;
            }
            if (num <= 8)
            {
                int num2 = num;
                while (--num2 >= 0)
                {
                    buffer[offset + num2] = this._buffer[this._position + num2];
                }
            }
            else
            {
                Buffer.BlockCopy(this._buffer, this._position, buffer, offset, num);
            }
            this._position += num;
            return num;
        }

        public override long Seek(long offset, System.IO.SeekOrigin origin)
        {
            switch (origin)
            {
                case SeekOrigin.Begin:
                    {
                        int num = this._origin + (int)offset;
                        
                        this._position = num;
                        break;
                    }
                case SeekOrigin.Current:
                    {
                        int num2 = this._position + (int)offset;
                        this._position = num2;
                        break;
                    }
                case SeekOrigin.End:
                    {
                        int num3 = this._length + (int)offset;
                       
                        this._position = num3;
                        break;
                    }
                
            }
            return (long)this._position;
        }

        public override void SetLength(long value)
        {
            int num = this._origin + (int)value;
            this._length = num;
            if (this._position > num)
            {
                this._position = num;
            }
        }

        public override void Write(byte[] buffer, int offset, int count)
        {
            
            int num = this._position + count;
            if (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.BlockCopy(buffer, offset, this._buffer, this._position, count);
            }
            this._position = num;
        }
    }

总结

真的搞不明白为什么要这样设计,既然Length是可设置的即说明可以由开发人员指定现在流的内容长度,开发人员在设置之也会意识到相应buffer的数据信息.更何况Length的改变并不会更改postion位置,在后面对Stream的写入自然会把之前的内容代替.

如果那位同学以后要这样使用MemoryStream就要注意一下了:)