• C# 流Stream详解（3）——FileStream源码

    【FileStream】

    构造函数

    如果创建一个FileStream，常见的参数例如路径Path、操作方式FileMode、权限FileAccess。

    这里说下FileShare和SafeFileHandle。

    我们知道在读取文件时，通常会有两个诉求：一是如何更快的读取文件内容；二是如何减少读取文件的消耗。常见的加快读取文件的方式是多线程读取，每个线程读取文件的一部分，这就涉及到文件的共享，有以下几种模式：

    • None：拒绝共享，其他线程（进程）将不能打开、写入、删除该文件
    • Read：允许读取，其他线程可以自己new一个FileStream实例来读取文件，线程之间读文件不影响，其中一个线程的FileStream释放后，不影响其他线程读文件。
    • Write：允许写入，其他线程之间并行写入，需要注意的是，不同线程要在不同的流位置和流区间写入，不要重叠，否则重叠的部分是串行的。
    • ReadWrite：允许读写,这种方式不常用，在并行时最需要保证的是不同线程读写文件的不同区间，不要重叠。
    • Delete：允许删除
    • Ineritable：允许文件句柄由子进程继承

    SafeFileHandle用的很少，一般来多语言交互的时候用到，比如在C++打开了一个文件，要把引用传递给C#，C#这边来读取文件，或者C#打开文件，传递给C++读取文件。这种情况出现的很少，如果真的需要C++和C#传递文件数据，一般会将文件路径传递，打开读取文件在一端进行，或者在一端打开读取文件后将包含数据的buffer传递到另一端。如果要用的话，示例如下：

    1.     [DllImport("kernel32.dll", SetLastError = true, CharSet=CharSet.Unicode)]
    2.     static extern SafeFileHandle CreateFile(string lpFileName, uint dwDesiredAccess,
    3.       uint dwShareMode, IntPtr lpSecurityAttributes, uint dwCreationDisposition,
    4.       uint dwFlagsAndAttributes, IntPtr hTemplateFile);
    5.  
    6. public void ReadFile()
    7. {
    8. SafeFileHandle fileHandle = CreateFile(
    9. "example.txt",
    10. GENERIC_READ,
    11. FILE_SHARE_READ,
    12. IntPtr.Zero,
    13. OPEN_EXISTING,
    14. FILE_ATTRIBUTE_NORMAL,
    15. IntPtr.Zero
    16. );
    17.  
    18. byte[] buffer = new byte[1024];
    19. using (FileStream fileStream = new FileStream(fileHandle, FileAccess.Read))
    20. {
    21. int bytesRead = fileStream.Read(buffer, 0, buffer.Length);
    22. //FileStream.SafeFileHandle.DangerousGetHandle() 获取文件句柄
    23. }
    24. }

    方法

    Read、Write、Dispose和Close没什么好说的，很常用。这里看看不常用的其他方法。

    • Flush：读写文件是一个很复杂的过程，当我们调用write方法尝试将数据写到磁盘上时，即使我们调用了同步的方法，也不是立即写入磁盘，而是先写入FileStream的buffer中。FileStream buffer的默认大小为4kb，我们可以在实例化的时候指定buffer大小。当调用Write方法时，会先将数据写入buffer，如果buffer满了，就将数据写入操作系统的buffer中。（buffer在写入时会分配内存，如果第一次写入的count大于buffersize，那么直接写入操作系统buffer中，否则即使count>buffersize，也是先把buffer填满，再写入操作系统中，这里是个优化的点）。Flush()相当于Flush(false)，会立即将buffer中的数据写入操作系统的buffer，并清空buffer中;Flush(true)会将操作系统的buffer也清空，并执行写入磁盘的操作。
    • Lock:锁定文件流void Lock (long position, long length)，将文件流的一部分锁定进行独占访问。与之对应的是UnLock。

    • Read(Span)：如果不了解Span，可以先了解下。Span表示一段连续的内存，有时我们希望直接操作一段内存，安全的方式是先将这段内存的内容copy出来，但是这样性能不高。想要高性能，就要使用指针去访问，但这样不安全。Span提供安全高效的内存访问。用该方法，可以直接将读取的字节序列放到Span引用的连续内存中。

    • ReadExactly：其与Read的区别是，在读取一定的字节序列后，会推进流的位置，也即改变Position属性的值。

    源码（反编译来的）

    对于上层调用者来说，FileStream提供了一个中间缓存层。每多一个中间层，就需要在中间层中处理好中间层和下层的共同属性之间的关系，这里指Position的关系。

    读取数据

    1. public override int Read([In][Out] byte[] array, int offset, int count)
    2. {
    3.     if (array == null)
    4.     {
    5.         throw new ArgumentNullException("array", Environment.GetResourceString("ArgumentNull_Buffer"));
    6.     }
    7.  
    8.     if (offset < 0)
    9.     {
    10.         throw new ArgumentOutOfRangeException("offset", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
    11.     }
    12.  
    13.     if (count < 0)
    14.     {
    15.         throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
    16.     }
    17.  
    18.     if (array.Length - offset < count)
    19.     {
    20.         throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
    21.     }
    22.  
    23.     if (_handle.IsClosed)//这是SafeFileHandle
    24.     {
    25.         __Error.FileNotOpen();
    26.     }
    27.  
    28.     bool flag = false;
    29.     int num = _readLen - _readPos;//read和write共用一个buffer，readlen表示用于读数据的长度，这里求的是读数据buffer的剩余可用大小
    30.     if (num == 0)//用于读的buffer的长度和位置相等，表示用于读的buffer用满了
    31.     {
    32.         if (!CanRead)
    33.         {
    34.             __Error.ReadNotSupported();
    35.         }
    36.  
    37.         if (_writePos > 0)//此时需要清空写入的buffer
    38.         {
    39.             FlushWrite(calledFromFinalizer: false);
    40.         }
    41.  
    42.         if (!CanSeek || count >= _bufferSize)//如果要求的count大于buffer的大小时，会直接将读出来的数据放入到指定的array中，少了copy的步骤
    43.         {                                   //如果FilsStream只是用于读数据，可以指定小的buffersize，将读到的数据直接放入指定的array中，减少从buffer到array的拷贝
    44.             num = ReadCore(array, offset, count);
    45.             _readPos = 0;
    46.             _readLen = 0;
    47.             return num;
    48.         }
    49.  
    50.         if (_buffer == null)//实例化buffer
    51.         {
    52.             _buffer = new byte[_bufferSize];
    53.         }
    54.  
    55.         num = ReadCore(_buffer, 0, _bufferSize);//注意，如果指定的count小于buffer，那么实际是按照buffersize的大小来读取数据的
    56.         if (num == 0)                           //这样做是为了减少IO消耗，底层在读取磁盘数据时，会一次性读取扇区里的全部内容，而不是按照上层指定的读取只读取几个字节
    57.                                                 //因此，读文件的操作不一定真的有IO消耗，如果每次读的小，会用到这里的缓存数据
    58.         {
    59.             return 0;
    60.         }
    61.  
    62.         flag = (num < _bufferSize);//这种情况表示文件大小（或者文件剩余大小）小于指定的buffer大小，buffer大小默认4kb
    63.         _readPos = 0;
    64.         _readLen = num;
    65.     }
    66.  
    67.     if (num > count)
    68.     {
    69.         num = count;
    70.     }
    71.  
    72.     Buffer.InternalBlockCopy(_buffer, _readPos, array, offset, num);//将buffer里的数据copy到指定的array中
    73.     _readPos += num;//读数据时流的位置会增加
    74.     if (!_isPipe && num < count && !flag)//isPipe一般为false，这种情况表示指定的count比读数据buffer的可用数据大
    75.     {                                  //步骤是先将buffer里的数据copy到指定的array中，然后再从文件中读剩余(count-num)个数据
    76.         int num2 = ReadCore(array, offset + num, count - num);
    77.         num += num2;
    78.         _readPos = 0;//读数据的Buffer被读取完了，流的位置和大小都回置为0
    79.         _readLen = 0;
    80.     }
    81.  
    82.     return num;
    83. }

    写入数据

    1. public override void Write(byte[] array, int offset, int count)
    2. {
    3.     if (array == null)
    4.     {
    5.         throw new ArgumentNullException("array", Environment.GetResourceString("ArgumentNull_Buffer"));
    6.     }
    7.  
    8.     if (offset < 0)
    9.     {
    10.         throw new ArgumentOutOfRangeException("offset", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
    11.     }
    12.  
    13.     if (count < 0)
    14.     {
    15.         throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
    16.     }
    17.  
    18.     if (array.Length - offset < count)
    19.     {
    20.         throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
    21.     }
    22.  
    23.     if (_handle.IsClosed)
    24.     {
    25.         __Error.FileNotOpen();
    26.     }
    27.  
    28.     if (_writePos == 0
    29.     {
    30.         if (!CanWrite)
    31.         {
    32.             __Error.WriteNotSupported();
    33.         }
    34.  
    35.         if (_readPos < _readLen)//这种情况表示要写数据时，buffer中还有一些数据没被上层读完，需要情况，回退读的位置
    36.         {                       //读写共用一个buffer，读时清空写的数据，写时清空读的数据
    37.             FlushRead();
    38.         }
    39.  
    40.         _readPos = 0;
    41.         _readLen = 0;
    42.     }
    43.  
    44.     if (_writePos > 0)
    45.     {
    46.         int num = _bufferSize - _writePos;//计算剩余可写入大小，
    47.         if (num > 0)
    48.         {
    49.             if (num > count)
    50.             {
    51.                 num = count;
    52.             }
    53.  
    54.             Buffer.InternalBlockCopy(array, offset, _buffer, _writePos, num);//将array中的数据copy了一份到buffer中，不是立即写入，会在关闭流的时候再写入
    55.             _writePos += num;//更新写入流的位置
    56.             if (count == num)
    57.             {
    58.                 return;//这种情况是剩余的写入大小大于指定的count
    59.             }
    60.  
    61.             offset += num;
    62.             count -= num;
    63.         }
    64.  
    65.         if (_isAsync)
    66.         {
    67.             IAsyncResult asyncResult = BeginWriteCore(_buffer, 0, _writePos, null, null);
    68.             EndWrite(asyncResult);
    69.         }
    70.         else
    71.         {
    72.             WriteCore(_buffer, 0, _writePos);//能走到这里，是因为count>num，此时buffer中数据已满，需要写入磁盘中
    73.         }
    74.  
    75.         _writePos = 0;
    76.     }
    77.  
    78.     if (count >= _bufferSize)//如果剩余的count或首次的count大于buffer大小，直接写入
    79.     {                       //这里写入是先将buffer填满再写入，多余的直接写入
    80.         WriteCore(array, offset, count);
    81.     }
    82.     else if (count != 0)
    83.     {
    84.         if (_buffer == null)
    85.         {
    86.             _buffer = new byte[_bufferSize];
    87.         }
    88.  
    89.         Buffer.InternalBlockCopy(array, offset, _buffer, _writePos, count);//如果写入指定的count小于剩余的写入大小，只是将array中的数据copy了一份到buffer中，不是立即写入，会在关闭流的时候再写入
    90.         _writePos = count;//更新写入流的位置
    91.     }
    92. }

    寻找位置

    1. public override long Position
    2. {
    3.     [SecuritySafeCritical]
    4.     get
    5.     {
    6.         if (_handle.IsClosed)
    7.         {
    8.             __Error.FileNotOpen();
    9.         }
    10.  
    11.         if (!CanSeek)
    12.         {
    13.             __Error.SeekNotSupported();
    14.         }
    15.  
    16.         if (_exposedHandle)//该值一般为false，get文件句柄时会被设置为true，此时文件流的位置，需要重新确定
    17.         {
    18.             VerifyOSHandlePosition();
    19.         }
    20.         //这里获取的不是真正的文件流的位置，而是上层调用者认为的流的位置
    21.         return _pos + (_readPos - _readLen + _writePos);
    22.     }
    23.     set
    24.     {
    25.         if (value < 0)
    26.         {
    27.             throw new ArgumentOutOfRangeException("value", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
    28.         }
    29.  
    30.         if (_writePos > 0)//如果有需要写入的内容，会将内容先写入
    31.         {
    32.             FlushWrite(calledFromFinalizer: false);
    33.         }
    34.  
    35.         _readPos = 0;
    36.         _readLen = 0;
    37.         Seek(value, SeekOrigin.Begin);//Position属性表示以流开始为起点的位置
    38.     }
    39. }
    40.  
    41.  
    42. public override long Seek(long offset, SeekOrigin origin)
    43. {
    44.     if (origin < SeekOrigin.Begin || origin > SeekOrigin.End)
    45.     {
    46.         throw new ArgumentException(Environment.GetResourceString("Argument_InvalidSeekOrigin"));
    47.     }
    48.  
    49.     if (_handle.IsClosed)
    50.     {
    51.         __Error.FileNotOpen();
    52.     }
    53.  
    54.     if (!CanSeek)
    55.     {
    56.         __Error.SeekNotSupported();
    57.     }
    58.  
    59.     if (_writePos > 0)
    60.     {
    61.         FlushWrite(calledFromFinalizer: false);
    62.     }
    63.     else if (origin == SeekOrigin.Current)
    64.     {
    65.         offset -= _readLen - _readPos;//如果以当前为起点，_readPos表示FilsStream的buffer的Pos，而不是文件流的真正的Position
    66.     }                                   //offset表示调用者认为的Position，（_readLen - _readPos）表示文件流真正的Position和调用者认为的Position之间的差值
    67.  
    68.     if (_exposedHandle)
    69.     {
    70.         VerifyOSHandlePosition();//实际上时调用SeekCore(0L, SeekOrigin.Current)，重新定位下文件流的位置
    71.     }
    72.  
    73.     long num = _pos + (_readPos - _readLen);//计算出来的文件流的真正位置
    74.     long num2 = SeekCore(offset, origin);//重新定位文件流的位置
    75.     if (_appendStart != -1 && num2 < _appendStart)
    76.     {
    77.         SeekCore(num, SeekOrigin.Begin);
    78.         throw new IOException(Environment.GetResourceString("IO.IO_SeekAppendOverwrite"));
    79.     }
    80.  
    81.     if (_readLen > 0)//这表示之前已经读取了部分文件信息
    82.     {
    83.         if (num == num2)//一般是这种情况
    84.         {
    85.             if (_readPos > 0)//以readPos为分界线，把buffer中后面的数据拷贝到前面，这样readPos为0了，readLen减少了
    86.             {
    87.                 Buffer.InternalBlockCopy(_buffer, _readPos, _buffer, 0, _readLen - _readPos);
    88.                 _readLen -= _readPos;
    89.                 _readPos = 0;
    90.             }
    91.  
    92.             if (_readLen > 0)//恢复文件流的真正位置
    93.             {
    94.                 SeekCore(_readLen, SeekOrigin.Current);
    95.             }
    96.         }
    97.         else if (num - _readPos < num2 && num2 < num + _readLen - _readPos)//表示重新定位的文件流的位置小于计算出来的文件流的位置
    98.         {                                                               //大于上次读取文件流时得位置
    99.             int num3 = (int)(num2 - num);
    100.             Buffer.InternalBlockCopy(_buffer, _readPos + num3, _buffer, 0, _readLen - (_readPos + num3));
    101.             _readLen -= _readPos + num3;
    102.             _readPos = 0;
    103.             if (_readLen > 0)
    104.             {
    105.                 SeekCore(_readLen, SeekOrigin.Current);
    106.             }
    107.         }
    108.         else
    109.         {
    110.             _readPos = 0;
    111.             _readLen = 0;
    112.         }
    113.     }
    114.  
    115.     return num2;
    116. }
    117. //可以看到Seek流程很复杂，为了提高性能，应该避免再读数据时比默认buffersize大，直接读到指定的array中，不要经过FileStream的buffer。
    118. //一定要避免写数据和读数据交叉进行
    119. //因为filsStream的设计考虑了通用，当我们按照一定的规范去使用时，可以减少很多为通用情况而做的耗费性能的设计

    【MemoryStream】

    构造函数

    只需要关注红色方框里的两个构造函数即可，其他的都是重载。

    memorystream也有一个buffer来缓存数据，在new的时候可以指定这个buffer的大小，那么这个buffer的实例化在new的时候完成，如果在写数据时这个buffer的大小不够用，则会自动扩容。

    也可以自己实例化一个buffer，并在new的时候通过index和count来指定memorystream可以用这个buffer的哪一部分。通过这种方式new时，如果写数据时大小不够用，是不能扩容的。

    writable表示是否可以写入

    publiclyVisible表示是否可以拿到memorystream内部的buffer

    方法

    写入数据

    1. public override void Write(byte[] buffer, int offset, int count)
    2. {
    3.     if (buffer == null)
    4.     {
    5.         throw new ArgumentNullException("buffer", Environment.GetResourceString("ArgumentNull_Buffer"));
    6.     }
    7.  
    8.     if (offset < 0)
    9.     {
    10.         throw new ArgumentOutOfRangeException("offset", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
    11.     }
    12.  
    13.     if (count < 0)
    14.     {
    15.         throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
    16.     }
    17.  
    18.     if (buffer.Length - offset < count)
    19.     {
    20.         throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
    21.     }
    22.  
    23.     if (!_isOpen)
    24.     {
    25.         __Error.StreamIsClosed();
    26.     }
    27.  
    28.     EnsureWriteable();//确保可以写入，不能不能写入会报错，不继续执行了
    29.     int num = _position + count; //计算加入全部写入时流的位置
    30.     if (num < 0) //超出int可表示的最大值的检查，可以注意下，一般自己写代码时很少会做这种检查，虽然一般情况下也不需要
    31.     {              //MemoryStream的最大容量是int.MaxValue
    32.         throw new IOException(Environment.GetResourceString("IO.IO_StreamTooLong"));
    33.     }
    34.  
    35.     if (num > _length)//全部写入时流的位置大于buffer的长度，就需要扩容了
    36.     {
    37.         bool flag = _position > _length;
    38.         if (num > _capacity && EnsureCapacity(num))
    39.         {
    40.             flag = false;
    41.         }
    42.  
    43.         if (flag)//流的位置大于Buffer长度，需要清除多余的部分
    44.         {
    45.             Array.Clear(_buffer, _length, num - _length);
    46.         }
    47.  
    48.         _length = num;
    49.     }
    50.  
    51.     if (count <= 8 && buffer != _buffer) //当字节小于8时则一个个读
    52.     {
    53.         int num2 = count;
    54.         while (--num2 >= 0)
    55.         {
    56.             _buffer[_position + num2] = buffer[offset + num2];
    57.         }
    58.     }
    59.     else//将提供的buffer数据拷贝到MemoryStream的buffer种
    60.     {  //Buffer.BlockCopy比Array.Copy更快
    61.        //https://stackoverflow.com/questions/1389821/array-copy-vs-buffer-blockcopy
    62.         Buffer.InternalBlockCopy(buffer, offset, _buffer, _position, count);
    63.     }
    64.  
    65.    _position = num;//更新流的位置
    66. }
    67.  
    68.  
    69. private bool EnsureCapacity(int value)
    70. {
    71.     if (value < 0)
    72.     {
    73.         throw new IOException(Environment.GetResourceString("IO.IO_StreamTooLong"));
    74.     }
    75.  
    76.     if (value > _capacity)
    77.     {
    78.         int num = value;
    79.         if (num < 256)
    80.         {
    81.             num = 256;//容量小于256时，会被规范为256
    82.         }
    83.  
    84.         if (num < _capacity * 2)
    85.         {
    86.             num = _capacity * 2;//两倍扩容
    87.         }
    88.  
    89.         if ((uint)(_capacity * 2) > 2147483591u)//处理超限
    90.         {
    91.             num = ((value > 2147483591) ? value : 2147483591);
    92.         }
    93.  
    94.         Capacity = num;
    95.         return true;
    96.     }
    97.  
    98.     return false;
    99. }
    100.  
    101. public virtual int Capacity
    102. {
    103.     [__DynamicallyInvokable]
    104.     get
    105.     {
    106.         if (!_isOpen)
    107.         {
    108.             __Error.StreamIsClosed();
    109.         }
    110.  
    111.         return _capacity - _origin;
    112.     }
    113.     [__DynamicallyInvokable]
    114.     set
    115.     {
    116.         if (value < Length)
    117.         {
    118.             throw new ArgumentOutOfRangeException("value", Environment.GetResourceString("ArgumentOutOfRange_SmallCapacity"));
    119.         }
    120.  
    121.         if (!_isOpen)
    122.         {
    123.             __Error.StreamIsClosed();
    124.         }
    125.  
    126.         if (!_expandable && value != Capacity)
    127.         {
    128.             __Error.MemoryStreamNotExpandable();
    129.         }
    130.  
    131.         if (!_expandable || value == _capacity)//new时指定了buffer就不能扩容了
    132.         {
    133.             return;
    134.         }
    135.  
    136.         if (value > 0)
    137.         {
    138.             byte[] array = new byte[value];
    139.             if (_length > 0)//扩容时会将原来的数据copy到新的buffer种
    140.             {
    141.                 Buffer.InternalBlockCopy(_buffer, 0, array, 0, _length);
    142.             }
    143.  
    144.             _buffer = array;
    145.         }
    146.         else
    147.         {
    148.             _buffer = null;
    149.         }
    150.  
    151.         _capacity = value;
    152.     }
    153. }

    读取数据

    1. public override int Read([In][Out] byte[] buffer, int offset, int count)//理解了write后，read方法很简单
    2. {
    3.     if (buffer == null)
    4.     {
    5.         throw new ArgumentNullException("buffer", Environment.GetResourceString("ArgumentNull_Buffer"));
    6.     }
    7.  
    8.     if (offset < 0)
    9.     {
    10.         throw new ArgumentOutOfRangeException("offset", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
    11.     }
    12.  
    13.     if (count < 0)
    14.     {
    15.         throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
    16.     }
    17.  
    18.     if (buffer.Length - offset < count)
    19.     {
    20.         throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
    21.     }
    22.  
    23.     if (!_isOpen)
    24.     {
    25.         __Error.StreamIsClosed();
    26.     }
    27.  
    28.     int num = _length - _position;
    29.     if (num > count)
    30.     {
    31.         num = count;
    32.     }
    33.  
    34.     if (num <= 0)
    35.     {
    36.         return 0;
    37.     }
    38.  
    39.     if (num <= 8)
    40.     {
    41.         int num2 = num;
    42.         while (--num2 >= 0)
    43.         {
    44.             buffer[offset + num2] = _buffer[_position + num2];
    45.         }
    46.     }
    47.     else
    48.     {
    49.         Buffer.InternalBlockCopy(_buffer, _position, buffer, offset, num);//将数据拷贝到指定的buffer中
    50.     }
    51.  
    52.     _position += num;//读完后，流的position增加
    53.     return num;
    54. }

    【BinaryWriter】

    构造函数

     Stream参数，FileStream、MemoryStream都继承自Stream，这里传递进来主要是要用这些Stream的buffer

    Encoding 编码类型，默认是new UTF8Encoding()

    leaveOpen:表示close时要不要把stream要不要保持打开，默认为false,会将stream也close 

    方法

    1. //可以每次写入实际是将数据写入Stream的buffer中，BinaryWriter将数据序列化了，这里只提供基本数据类型的序列化
    2. public virtual void Write(bool value)//写入bool
    3. {
    4.     _buffer[0] = (byte)(value ? 1u : 0u);//bool也是byte
    5.     OutStream.Write(_buffer, 0, 1);//BinaryWriter也有有个buffer，固定的长度，为16，之所以为16是因为有个decimal类型要有16个字节表示
    6. }
    7.  
    8. public virtual void Write(byte value)//byte直接写入
    9. {
    10.     OutStream.WriteByte(value);
    11. }
    12.  
    13. public virtual void Write(byte[] buffer)
    14. {
    15.     if (buffer == null)
    16.     {
    17.         throw new ArgumentNullException("buffer");
    18.     }
    19.  
    20.     OutStream.Write(buffer, 0, buffer.Length);//byte[]一样是直接写入到stream的buffer中
    21. }
    22.  
    23. public virtual void Write(short value)
    24. {
    25.     _buffer[0] = (byte)value;//先取到低八位
    26.     _buffer[1] = (byte)(value >> 8);//右移取到高八位
    27.     OutStream.Write(_buffer, 0, 2);
    28. }
    29.  
    30. public virtual void Write(int value)
    31. {
    32.     _buffer[0] = (byte)value;
    33.     _buffer[1] = (byte)(value >> 8);
    34.     _buffer[2] = (byte)(value >> 16);
    35.     _buffer[3] = (byte)(value >> 24);
    36.     OutStream.Write(_buffer, 0, 4);
    37. }
    38.  
    39. public virtual void Write(long value)
    40. {
    41.     _buffer[0] = (byte)value;
    42.     _buffer[1] = (byte)(value >> 8);
    43.     _buffer[2] = (byte)(value >> 16);
    44.     _buffer[3] = (byte)(value >> 24);
    45.     _buffer[4] = (byte)(value >> 32);
    46.     _buffer[5] = (byte)(value >> 40);
    47.     _buffer[6] = (byte)(value >> 48);
    48.     _buffer[7] = (byte)(value >> 56);
    49.     OutStream.Write(_buffer, 0, 8);
    50. }
    51.  
    52. public unsafe virtual void Write(string value)
    53. {
    54.     if (value == null)
    55.     {
    56.         throw new ArgumentNullException("value");
    57.     }
    58.  
    59.     int byteCount = _encoding.GetByteCount(value);
    60.     Write7BitEncodedInt(byteCount);//会先写入字符串的byte长度
    61.     if (_largeByteBuffer == null)
    62.     {
    63.         _largeByteBuffer = new byte[256];//先尝试用一个256长度的Buffer做首次尝试
    64.         _maxChars = _largeByteBuffer.Length / _encoding.GetMaxByteCount(1);//获取该编码格式下，最大的字符需要多少byte，maxChar表示largeByteBuffer最多可以容纳多少个字符
    65.     }
    66.  
    67.     if (byteCount <= _largeByteBuffer.Length)//小256,就直接将编码得到的bytes放入largeByteBuffer，再copy到Stream的buffer中
    68.     {
    69.         _encoding.GetBytes(value, 0, value.Length, _largeByteBuffer, 0);
    70.         OutStream.Write(_largeByteBuffer, 0, byteCount);
    71.         return;
    72.     }
    73.  
    74.     int num = 0;
    75.     int num2 = value.Length;
    76.     while (num2 > 0)//字符串的长度大于128时，将字符串拆分转为bytes，分别写入largeByteBuffer
    77.     {
    78.         int num3 = (num2 > _maxChars) ? _maxChars : num2;
    79.         if (num < 0 || num3 < 0 || checked(num + num3) > value.Length)
    80.         {
    81.             throw new ArgumentOutOfRangeException("charCount");
    82.         }
    83.  
    84.         int bytes2;
    85.         fixed (char* ptr = value)
    86.         {
    87.             fixed (byte* bytes = _largeByteBuffer)
    88.             {
    89.                 //因为字符串不可修改，要使用指针读取，这个方法表示的意思和之前的_encoder.GetBytes是一样的，
    90.                 bytes2 = _encoder.GetBytes((char*)checked(unchecked((nuint)ptr) + unchecked((nuint)checked(unchecked((nint)num) * (nint)2))), num3, bytes, _largeByteBuffer.Length, num3 == num2);
    91.             }
    92.         }
    93.  
    94.         OutStream.Write(_largeByteBuffer, 0, bytes2);
    95.         num += num3;
    96.         num2 -= num3;
    97.     }
    98. }
    99.  
    100.  
    101. protected void Write7BitEncodedInt(int value)//用于将整数值编码为7位压缩格式并写入流中。
    102. {                                           //它通常用于数据序列化或网络通信过程中，以减小整数值的存储空间和传输开销。编码过程中，整数值按照7位的块进行分割，并将每个块的最高位设置为1，表示后面还有更多的块。每个块的其余7位用于存储整数值的一部分。
    103.     uint num;                               //这样，较小的整数值可以用较少的字节进行编码，而较大的整数值则需要更多的字节。
    104.     for (num = (uint)value; num >= 128; num >>= 7) //这种方式相比于之前的Write(int value),会减少存储空间
    105.     {
    106.         Write((byte)(num | 0x80));//0x80是 1000 0000,这里直接舍去了num的后七位
    107.     }
    108.  
    109.     Write((byte)num);
    110. }

    【BinaryReader】

    构造函数

     方法

    1. //可以发现真正读数据都是Stream完成的，BinaryReader将读出来的数据反序列化了，这里只提供byte到基本数据类型的反序列化
    2. public virtual byte ReadByte()//读byte
    3. {
    4.     if (m_stream == null)
    5.     {
    6.         __Error.FileNotOpen();
    7.     }
    8.  
    9.     int num = m_stream.ReadByte();//实际调用的是Stream的ReadByte方法,最低读8位
    10.     if (num == -1)
    11.     {
    12.         __Error.EndOfFile();
    13.     }
    14.  
    15.     return (byte)num;
    16. }
    17.  
    18. public virtual short ReadInt16()//读short
    19. {
    20.     FillBuffer(2);//16/8=2
    21.     return (short)(m_buffer[0] | (m_buffer[1] << 8));//低位在前面，高位在后面，这是小端模式存储
    22. }
    23.  
    24. public virtual int ReadInt32()//读int
    25. {
    26.     if (m_isMemoryStream)//new BinaryStream会判断下Stream是不是MemoryStream
    27.     {
    28.         if (m_stream == null)
    29.         {
    30.             __Error.FileNotOpen();
    31.         }
    32.  
    33.         MemoryStream memoryStream = m_stream as MemoryStream;
    34.         return memoryStream.InternalReadInt32();
    35.     }
    36.  
    37.     FillBuffer(4);//32/8=4
    38.     return m_buffer[0] | (m_buffer[1] << 8) | (m_buffer[2] << 16) | (m_buffer[3] << 24);
    39. }
    40.  
    41. public unsafe virtual float ReadSingle()//读取float
    42. {
    43.     FillBuffer(4);
    44.     uint num = (uint)(m_buffer[0] | (m_buffer[1] << 8) | (m_buffer[2] << 16) | (m_buffer[3] << 24));
    45.     return *(float*)(&num);
    46. }
    47.  
    48. public unsafe virtual double ReadDouble()//读取double
    49. {
    50.     FillBuffer(8);
    51.     uint num = (uint)(m_buffer[0] | (m_buffer[1] << 8) | (m_buffer[2] << 16) | (m_buffer[3] << 24));
    52.     uint num2 = (uint)(m_buffer[4] | (m_buffer[5] << 8) | (m_buffer[6] << 16) | (m_buffer[7] << 24));
    53.     ulong num3 = ((ulong)num2 << 32) | num;
    54.     return *(double*)(&num3);
    55. }
    56.  
    57.  
    58. public virtual string ReadString()
    59. {
    60.     if (m_stream == null)
    61.     {
    62.         __Error.FileNotOpen();
    63.     }
    64.  
    65.     int num = 0;
    66.     int num2 = Read7BitEncodedInt();//读取字符串长度
    67.     if (num2 < 0)
    68.     {
    69.         throw new IOException(Environment.GetResourceString("IO.IO_InvalidStringLen_Len", num2));
    70.     }
    71.  
    72.     if (num2 == 0)
    73.     {
    74.         return string.Empty;
    75.     }
    76.  
    77.     if (m_charBytes == null)
    78.     {
    79.         m_charBytes = new byte[128];//这里是存储读取到的字节数组
    80.     }
    81.  
    82.     if (m_charBuffer == null)
    83.     {
    84.         m_charBuffer = new char[m_maxCharsSize];//这里存储的是字符数组  m_maxCharsSize = encoding.GetMaxCharCount(128);maxCharSize是该编码下128个字符的最大大小
    85.     }
    86.  
    87.     StringBuilder stringBuilder = null;
    88.     do
    89.     {
    90.         int count = (num2 - num > 128) ? 128 : (num2 - num);
    91.         int num3 = m_stream.Read(m_charBytes, 0, count);
    92.         if (num3 == 0)
    93.         {
    94.             __Error.EndOfFile();
    95.         }
    96.         //每次将charBytes数组中起始节点为0，数量为num3的数据解码放大charBuffer中，在charBuffer中的起始地址为0
    97.         int chars = m_decoder.GetChars(m_charBytes, 0, num3, m_charBuffer, 0);
    98.         if (num == 0 && num3 == num2)
    99.         {
    100.             return new string(m_charBuffer, 0, chars);//字符串长度小于128的就直接返回了
    101.         }
    102.  
    103.         if (stringBuilder == null)
    104.         {
    105.             stringBuilder = StringBuilderCache.Acquire(Math.Min(num2, 360));
    106.         }
    107.  
    108.         stringBuilder.Append(m_charBuffer, 0, chars);
    109.         num += num3;
    110.     }
    111.     while (num < num2);
    112.     return StringBuilderCache.GetStringAndRelease(stringBuilder);
    113. }
    114.  
    115. protected internal int Read7BitEncodedInt()
    116. {
    117.     int num = 0;
    118.     int num2 = 0;
    119.     byte b;
    120.     do
    121.     {
    122.         if (num2 == 35)
    123.         {
    124.             throw new FormatException(Environment.GetResourceString("Format_Bad7BitInt32"));
    125.         }
    126.  
    127.         b = ReadByte();
    128.         num |= (b & 0x7F) << num2;
    129.         num2 += 7;
    130.     }
    131.     while ((b & 0x80) != 0);
    132.     return num;
    133. }

  • 相关阅读:
    渗透测试基础，初识渗透测试
    【NR 物理资源】
    循环玩具游戏
    java题目汇总(一)
    ElasticSearch中关于Nasted嵌套查询的介绍：生动案例，通俗易懂，彻底吸收
    运用动态内存实现通讯录（增删查改+排序）
    矩阵可逆的充要条件及证明
    【Spring MVC】MVC如何浏览器请求（service方法）
    力扣(LeetCode)1732. 找到最高海拔(C++)
    java生成、识别条形码和二维码
  • 原文地址：https://blog.csdn.net/enternalstar/article/details/132477043