C#中MemoryStream类的介绍

MemoryStream位于System.IO命名空间，为系统内存提供流式的读写操作。常作为其他流数据交换时的中间对象操作。

1、MemoryStream类封装一个字节数组，在构造实例时可以使用一个字节数组作为参数，但是数组的长度无法调整。使用默认无参数构造函数创建实例，可以使用Write方法写入，随着字节数据的写入，数组的大小自动调整。

2、在对MemoryStream类中数据流进行读取时，可以使用seek方法定位读取器的当前的位置，可以通过指定长度的数组一次性读取指定长度的数据。ReadByte方法每次读取一个字节，并将字节返回一个整数值。

3、UnicodeEncoding类中定义了Unicode中UTF-16编码的相关功能。通过其中的方法将字符串转换为字节，也可以将字节转换为字符串。
MemoryStream 是一个特例，MemoryStream中没有任何非托管资源，所以它的Dispose不调用也没关系。托管资源.Net会自动回收

MemoryStream继承自Stream类。内存流的好处是指针可以晃来晃去，也就是支CanSeek，Position,Seek()。任意读其中一段。

在内存流中有必要了解一下SeekOrigin枚举

枚举成员成员值描述
Begin 0 指定流的开头。
Current 1 指定流内的当前位置。
End 2 指定流的结尾。

MemoryStream提供的属性与方法:
一、属性

CanRead 　　　　已重写。获取一个值，该值指示当前流是否支持读取。
CanSeek 　　　　已重写。获取一个值，该值指示当前流是否支持查找。
CanTimeout 　　 获取一个值，该值确定当前流是否可以超时。（从 Stream 继承。）
CanWrite 　　　 已重写。获取一个值，该值指示当前流是否支持写入。
Capacity 　　　　获取或设置分配给该流的字节数。 这个是分配的字节数
Length 　　　　 已重写。获取用字节表示的流长度。这个是真正占用的字节数。
Position 　　　　 已重写。获取或设置流中的当前位置。
ReadTimeout 　 获取或设置一个值，该值确定流在超时前尝试读取多长时间。 （从 Stream 继承。）
WriteTimeout 　 获取或设置一个值，该值确定流在超时前尝试写入多长时间。 （从 Stream 继承。）

二、方法

BeginRead 　　　　开始异步读操作。 （从 Stream 继承。）
BeginWrite　　　　开始异步写操作。 （从 Stream 继承。）
Close 　　　　　　 关闭当前流并释放与之关联的所有资源（如套接字和文件句柄）。 （从 Stream 继承。）
CreateObjRef　　 创建一个对象，该对象包含生成用于与远程对象进行通信的代理所需的全部相关信息。 （从 MarshalByRefObject 继承。）
Dispose　　　　　 已重载。
EndRead　　　　　等待挂起的异步读取完成。 （从 Stream 继承。）
EndWrite 　　　　 结束异步写操作。 （从 Stream 继承。）
Flush 　　　　　　 已重写。 重写 Stream.Flush 以便不执行任何操作。
GetBuffer 　　　　返回从其创建此流的无符号字节数组。 是会返回所有分配的字节，不管用没用到。
GetLifetimeService 　　　　 检索控制此实例的生存期策略的当前生存期服务对象。 （从 MarshalByRefObject 继承。）
InitializeLifetimeService 　　获取控制此实例的生存期策略的生存期服务对象。 （从 MarshalByRefObject 继承。）
Read　　　　　　　　　　　 已重写。 从当前流中读取字节块并将数据写入 buffer 中。 搞了好久才弄明白Read()方法的含义，第一个参数，是读取到的内容要输出到的字节数组，第二个参数是放在第一个参数即要输出的数组的位置的偏移量，第三个参数是，要读取的字符数。 用这个方法你可以任意读取一段需要的内存。注意，Read()方法是从当前流的Position属性的位置开始读，这就是为什么很多人测试的时候，刚刚写入内存的数据，Read()方法无法读取到内容的原因，因为刚刚写入内存之后，位置恰好是在最后一位了。Read()方法当然读不到。此方法强大之处在于，你可以从一个内存流中读出你想要的一个片段。
ReadByte 　　　　　　　　 已重写。 从当前流中读取一个字节。
Seek 　　　　　　　　　　　已重写。 将当前流中的位置设置为指定值。
SetLength 　　　　　　　　 已重写。 将当前流的长度设为指定值。
Synchronized 　　　　　　 在指定的 Stream 对象周围创建线程安全（同步）包装。 （从 Stream 继承。）
ToArray　　　　　　　　　 将整个流内容写入字节数组，而与 Position 属性无关。
Write 　　　　　　　　　　 已重写。 使用从缓冲区读取的数据将字节块写入当前流。 同样注意下，第二个参数是第一个参数数组的偏移量就可以了。
WriteByte 　　　　　　　　已重写。 将一个字节写入当前流中的当前位置。
WriteTo 　　　　　　　　　将此内存流的整个内容写入另一个流中。

以下给出使用示例代码：

  1.  
    static void Main(string[] args)
  2.  
    {
  3.  
    //属性测试
  4.  
    MemoryStream ms = new MemoryStream();
  5.  
    Console.WriteLine(ms.CanRead); //True 内存流可读
  6.  
    Console.WriteLine(ms.CanSeek); //True 内存流支持查找，指针移来移去的查找
  7.  
    Console.WriteLine(ms.CanTimeout); //False 内存流不支持超时
  8.  
    Console.WriteLine(ms.CanWrite); //True 内存流可写
  9.  
     
  10.  
    Console.WriteLine(ms.Capacity); //0 分配给该流的字节数
  11.  
    byte[] bytes = Encoding.UTF8.GetBytes("abcdedcba");
  12.  
    ms.Write(bytes, 0, bytes.Length); //已将一段文本写入内存
  13.  
    Console.WriteLine(ms.Capacity); //256 再次读取为文本流分配的字节数已经变成了256，看来内存流是根据需要的多少来分配的
  14.  
    Console.WriteLine(ms.Length); //9 这个是流长度，通常与英文的字符数一样，真正占用的字节数。
  15.  
     
  16.  
    Console.WriteLine(ms.Position); //9 流当前的位置，该属性可读可设置
  17.  
     
  18.  
    //Console.WriteLine(ms.ReadTimeout); 由于流不支持超时，此属性如果读取或者设置的话会报错
  19.  
    //Console.WriteLine(ms.WriteTimeout); 由于流不支持超时，此属性如果读取或者设置的话会报错
  20.  
     
  21.  
    //方法测试
  22.  
    byte[] byte1 = ms.GetBuffer(); //返回无符号字节数组 差点被忽悠了，无符号字节数组 其实就是byte(0~255),有符号字节sbyte(-128~127)
  23.  
    string str1 = Encoding.UTF8.GetString(byte1);
  24.  
    Console.WriteLine(str1); //输出 abcdedcba
  25.  
     
  26.  
    ms.Seek(2, SeekOrigin.Current); //设置当前流正在读取的位置 为开始位置即从0开始
  27.  
    //从内存中读取一个字节
  28.  
    int i = ms.ReadByte();
  29.  
    Console.WriteLine(i); //输出99
  30.  
    byte[] bytes3 = ms.ToArray();
  31.  
    foreach (byte b in bytes3)
  32.  
    {
  33.  
    Console.Write(b + "-");//用于对比 输出 97-98-99-100-101-100-99-98-97- 可以看到 0,1,2第二位刚好是99
  34.  
    }
  35.  
     
  36.  
    MemoryStream ms2 = new MemoryStream();
  37.  
    byte[] bytes6 = Encoding.UTF8.GetBytes("abcde");
  38.  
    ms2.Write(bytes6, 0, bytes6.Length);
  39.  
    Console.WriteLine(ms2.Position); //输出5 写完之后流的位置就到了最后，因此想用read读取必须加下面这一行代码。
  40.  
     
  41.  
    //ms2.Seek(0, SeekOrigin.Begin); //想要用Read方法读取完整的流，必须设置当前位置,Read是从Position的位置开始读。
  42.  
    ms2.Position = 0; //Read是从当前位置开始读，这行代码和上面一行意义一样。
  43.  
    byte[] byteArray = new byte[5] { 110, 110, 110, 110, 110 }; //99是经过YTF8解码之后是 n
  44.  
    ms2.Read(byteArray, 2, 1); //读取一个字节，byteArray的第一个元素中，(注意从0开始)
  45.  
    Console.WriteLine(Encoding.UTF8.GetString(byteArray)); //nnann
  46.  
    //ms2.Read(byteArray, 2, 2);
  47.  
    //Console.WriteLine(Encoding.UTF8.GetString(byteArray)); //nnabn //当超出接收数组总长度的时候，后面的元素会被移开
  48.  
     
  49.  
     
  50.  
    //设置当前流的长度
  51.  
    Console.WriteLine(ms.Length); //输出9 当前流的长度是9
  52.  
    ms.SetLength(20);
  53.  
    Console.WriteLine(ms.Length); //输出20
  54.  
    foreach (byte b in ms.ToArray()) //将流的内容也就是内存中的内容转换字节数组
  55.  
    {
  56.  
    Console.Write(b + "-"); //输出 97-98-99-100-101-100-99-98-97-0-0-0-0-0-0-0-0-0 由于设置了长度，因此空的自动补0
  57.  
    }
  58.  
    Console.WriteLine(Encoding.UTF8.GetString(ms.ToArray())); //输出 abcdedcba 虽然长度变长了，但是没影响读取数据
  59.  
     
  60.  
    MemoryStream ms1 = new MemoryStream();
  61.  
    byte[] bytes4 = ms1.ToArray();
  62.  
    Console.WriteLine("此内存流并没有写入数据(Write)" + Encoding.UTF8.GetString(bytes4));//输出 此内存流并没有写入数据(Write) 因为内存为空
  63.  
     
  64.  
     
  65.  
    //下面来一个指定位置的写入
  66.  
    MemoryStream ms3 = new MemoryStream();
  67.  
    byte[] bytesArr = Encoding.ASCII.GetBytes("abcdefg");
  68.  
    ms3.Write(bytesArr, 0, bytesArr.Length);
  69.  
    ms3.Position = 2;
  70.  
    ms3.WriteByte(97); //97代表的是a 这段代码的意思是，将原先第二个的c替换为a
  71.  
    string str = Encoding.ASCII.GetString(ms3.ToArray());
  72.  
    Console.WriteLine(str); //输出 abacdefg
  73.  
     
  74.  
    byte[] byteArr1 = Encoding.ASCII.GetBytes("kk");
  75.  
    ms3.Position = 4;
  76.  
    ms3.Write(byteArr1, 0, byteArr1.Length);
  77.  
    Console.WriteLine(Encoding.UTF8.GetString(ms3.ToArray())); //abadkkg //从第4位替换掉了两个字节为KK
  78.  
     
  79.  
    Console.ReadKey();
  80.  
    }

接下来实现数据类的转换：

  1.  
    using System.IO;
  2.  
    using System.Runtime.Serialization;
  3.  
    using System.Runtime.Serialization.Formatters.Binary;
  4.  
     
  5.  
    public class DataSwitch
  6.  
    {
  7.  
     
  8.  
    /// <summary>
  9.  
    /// 数据类对象转成字节流
  10.  
    /// </summary>
  11.  
    /// <param name="obj"></param>
  12.  
    /// <returns></returns>
  13.  
    /// //MemoryStream: 创建其支持存储区为内存的流。
  14.  
    //IFormatter : 提供将序列化对象格式化的功能。
  15.  
    public static byte[] ObjectToBytes(object obj)
  16.  
    {
  17.  
    using (MemoryStream ms = new MemoryStream())
  18.  
    {
  19.  
    // //以二进制格式将对象或整个连接对象图形序列化和反序列化。
  20.  
    IFormatter formatter = new BinaryFormatter();
  21.  
    //把字符串以二进制放进memStream中
  22.  
    formatter.Serialize(ms, obj);
  23.  
    //返回从其创建此流的无符号字节数组。 是会返回所有分配的字节，不管用没用到。
  24.  
    ////返回无符号字节数组 ，无符号字节数组 其实就是byte(0~255),有符号字节sbyte(-128~127)
  25.  
    return ms.GetBuffer();
  26.  
    }
  27.  
    }
  28.  
     
  29.  
    /// <summary>
  30.  
    /// 字节流转成数据类对象
  31.  
    /// </summary>
  32.  
    /// <param name="bytes"></param>
  33.  
    /// <returns></returns>
  34.  
    public static object BytesToObject(byte[] bytes)
  35.  
    {
  36.  
    using (MemoryStream ms = new MemoryStream(bytes))
  37.  
    {
  38.  
    // //以二进制格式将对象或整个连接对象图形序列化和反序列化。
  39.  
    IFormatter formatter = new BinaryFormatter();
  40.  
    //把字符串以二进制放进memStream中
  41.  
    return formatter.Deserialize(ms);
  42.  
    }
  43.  
    }
  44.  
    }

原文地址1：http://www.cnblogs.com/kissdodog/archive/2013/01/20/2868864.html

原文地址2：https://blog.csdn.net/elineSea/article/details/71703552

posted @ 2019-01-08 15:14  net-sky  阅读(12900)  评论(0)  编辑  收藏  举报