其他分享
首页 > 其他分享> > 【.NET流操作】Stream、MemoryStream

【.NET流操作】Stream、MemoryStream

作者：互联网

Stream

代表一个流，抽象类

Stream重要成员

int Read(byte[] buffer, int offset, int count)

这个方法包含了3个关键的参数：缓冲字节数组，位移偏量和读取字节个数，每次读取一个字节后会返回一个缓冲区中的总字节数
第一个参数：这个数组相当于一个空盒子，Read（）方法每次读取流中的一个字节将其放进这个空盒子中。（全部读完后便可使用buffer字节数组了）
第二个参数：表示位移偏量，告诉我们从流中哪个位置（偏移量）开始读取。
最后一个参数：就是读取多少字节数。
返回值便是总共读取了多少字节数.

abstract long Seek(long offset, SeekOrigin origin)

大家还记得Position属性么？其实Seek方法就是重新设定流中的一个位置，在说明offset参数作用之前大家先来了解下SeekOrigin这个枚举：
如果 offset 为负，则要求新位置位于 origin 指定的位置之前，其间隔相差 offset 指定的字节数。如果 offset 为零 (0)，则要求新位置位于由 origin 指定的位置处。
如果 offset 为正，则要求新位置位于 origin 指定的位置之后，其间隔相差 offset 指定的字节数.

Stream.Seek(-3,Origin.End);  表示在流末端往前数第3个位置
Stream.Seek(0,Origin.Begin); 表示在流的开头位置
Stream.Seek(3,Orig`in.Current); 表示在流的当前位置往后数第三个位置

查找之后会返回一个流中的一个新位置。其实说道这大家就能理解Seek方法的精妙之处了吧

abstract void Write(byte[] buffer,int offset,int count)

这个方法包含了3个关键的参数：缓冲字节数组，位移偏量和读取字节个数
和read方法不同的是 write方法中的第一个参数buffer已经有了许多byte类型
的数据，我们只需通过设置 offset和count来将buffer中的数据写入流中

virtual void Close()

关闭流并释放资源，在实际操作中，如果不用using的话，别忘了使用完流之后将其关闭

练习

using System.Text;

{
    byte[] buffer = null;

    string testString = "Stream!Hello world";
    char[] readCharArray = null;
    byte[] readBuffer = null;
    string readString = string.Empty;
    //关于MemoryStream 我会在后续章节详细阐述
    using (MemoryStream stream = new MemoryStream())
    {
        Console.WriteLine("初始字符串为：{0}", testString);
        //如果该流可写
        if (stream.CanWrite)
        {
            //首先我们尝试将testString写入流中
            buffer = Encoding.Default.GetBytes(testString);
            //我们从该数组的第一个位置开始写，长度为3，写完之后 stream中便有了数据
            stream.Write(buffer, 0, 3);

            Console.WriteLine("现在Stream.Postion在第{0}位置", stream.Position);//3

            //从刚才结束的位置（当前位置）往后移3位，到第6位
            long newPositionInStream = stream.CanSeek ? stream.Seek(3, SeekOrigin.Current) : 0;

            Console.WriteLine("重新定位后Stream.Postion在第{0}位置", newPositionInStream);
            if (newPositionInStream < buffer.Length)
            {
                //将从新位置（第6位）一直写到buffer的末尾，注意下stream已经写入了3个数据“Str”
                stream.Write(buffer, (int)newPositionInStream, buffer.Length - (int)newPositionInStream);
            }


            //写完后将stream的Position属性设置成0，开始读流中的数据
            stream.Position = 0;

            // 设置一个空的盒子来接收流中的数据，长度根据stream的长度来决定
            readBuffer = new byte[stream.Length];


            //设置stream总的读取数量 ，
            //注意！这时候流已经把数据读到了readBuffer中
            int count = stream.CanRead ? stream.Read(readBuffer, 0, readBuffer.Length) : 0;


            //由于刚开始时我们使用加密Encoding的方式,所以我们必须解密将readBuffer转化成Char数组，这样才能重新拼接成string

            //首先通过流读出的readBuffer的数据求出从相应Char的数量
            int charCount = Encoding.Default.GetCharCount(readBuffer, 0, count);
            //通过该Char的数量 设定一个新的readCharArray数组
            readCharArray = new char[charCount];
            //Encoding 类的强悍之处就是不仅包含加密的方法，甚至将解密者都能创建出来（GetDecoder()），
            //解密者便会将readCharArray填充（通过GetChars方法，把readBuffer 逐个转化将byte转化成char，并且按一致顺序填充到readCharArray中）
            Encoding.Default.GetDecoder().GetChars(readBuffer, 0, count, readCharArray, 0);
            for (int i = 0; i < readCharArray.Length; i++)
            {
                readString += readCharArray[i];
            }
            Console.WriteLine("读取的字符串为：{0}", readString);
        }

        stream.Close();
    }
    Console.ReadKey();
}

MemoryStream

MemoryStream是内存流,为系统内存提供读写操作，所以它担当起了一些其他流进行数据交换时的中间工作，内存一般用于暂时缓存数据以降低应用程序对临时缓冲区(临时缓冲区)和临时文件的需要。在很多场合我们必须使用它来提高性能，比如：操作文件通过MemoryStream来实际进行读写，最后放入到相应的FileStream中,
不仅如此，在诸如XmlWriter的操作中也需要使用到MemoryStream提高读写速度

MemoryStream构造函数：

public MemoryStream();该构造函数初始分配的容量大小为0，随着数据的不断写入，其容量可以不断地自动扩展。
public MemoryStream(byte[] buffer);根据字节数组buffer初始化，实例的容量大小规定为字节数组的长度。
public MemoryStream(int capacity);容量固定为capacity。

案例： XmlWriter中使用MemoryStream

/// <summary>
/// 演示在xmlWriter中使用MemoryStream
/// </summary>
public static void UseMemoryStreamInXMLWriter()
{
    MemoryStream ms = new MemoryStream();
    using (ms)
    {
        //定义一个XMLWriter
        using (XmlWriter writer = XmlWriter.Create(ms))
        {
            //写入xml头
            writer.WriteStartDocument(true);
            //写入一个元素
            writer.WriteStartElement("Content");
            //为这个元素新增一个test属性
            writer.WriteStartAttribute("test");
            //设置test属性的值
            writer.WriteValue("逆时针的风");
            //释放缓冲，这里可以不用释放，但是在实际项目中可能要考虑部分释放对性能带来的提升
            writer.Flush();
            Console.WriteLine("此时内存使用量为:{2}KB,该MemoryStream的已经使用的容量为{0}byte,默认容量为{1}byte",
                Math.Round((double)ms.Length, 4), ms.Capacity,GC.GetTotalMemory(false)/1024);
            Console.WriteLine("重新定位前MemoryStream所在的位置是{0}",ms.Position);
            //将流中所在的当前位置往后移动7位，相当于空格
            ms.Seek(7, SeekOrigin.Current);
            Console.WriteLine("重新定位后MemoryStream所在的位置是{0}", ms.Position);
            //如果将流所在的位置设置为如下所示的位置则xml文件会被打乱
            //ms.Position = 0;
            writer.WriteStartElement("Content2");
            writer.WriteStartAttribute("testInner");
            writer.WriteValue("逆时针的风Inner");
            writer.WriteEndElement();
            writer.WriteEndElement();
            //再次释放
            writer.Flush();
            Console.WriteLine("此时内存使用量为:{2}KB,该MemoryStream的已经使用的容量为{0}byte,默认容量为{1}byte",
                Math.Round((double)ms.Length, 4), ms.Capacity, GC.GetTotalMemory(false)/1024);
            //建立一个FileStream  文件创建目的地是d:\test.xml
            FileStream fs = new FileStream(@"d:\test.xml",FileMode.OpenOrCreate);
            using (fs)
            {
                //将内存流注入FileStream
                ms.WriteTo(fs);
                if(ms.CanWrite)
                  //释放缓冲区
                fs.Flush();
            }
        }
    }
}

参考：

标签：Stream,MemoryStream,stream,buffer,writer,ms,NET,byte
来源： https://www.cnblogs.com/fanfan-90/p/16342520.html