• System.IO.MemoryStream.cs


    ylbtech-System.IO.MemoryStream.cs
    1.返回顶部
    1、
    #region 程序集 mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
    // C:Program Files (x86)Reference AssembliesMicrosoftFramework.NETFrameworkv4.5mscorlib.dll
    #endregion
    
    using System.Runtime;
    using System.Runtime.InteropServices;
    using System.Threading;
    using System.Threading.Tasks;
    
    namespace System.IO
    {
        //
        // 摘要:
        //     创建一个流,其后备存储为内存。若要浏览此类型的.NET Framework 源代码,请参阅 Reference Source。
        [ComVisible(true)]
        public class MemoryStream : Stream
        {
            //
            // 摘要:
            //     使用初始化为零的可扩展容量初始化 System.IO.MemoryStream 类的新实例。
            public MemoryStream();
            //
            // 摘要:
            //     使用按指定要求初始化的可扩展容量初始化 System.IO.MemoryStream 类的新实例。
            //
            // 参数:
            //   capacity:
            //     内部数组的初始大小(以字节为单位)。
            //
            // 异常:
            //   T:System.ArgumentOutOfRangeException:
            //     capacity 为负。
            public MemoryStream(int capacity);
            //
            // 摘要:
            //     基于指定的字节数组初始化 System.IO.MemoryStream 类的无法调整大小的新实例。
            //
            // 参数:
            //   buffer:
            //     从中创建当前流的无符号字节数组。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     buffer 为 null。
            [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
            public MemoryStream(byte[] buffer);
            //
            // 摘要:
            //     在 System.IO.MemoryStream.CanWrite 属性按指定设置的状态下,基于指定的字节数组初始化 System.IO.MemoryStream
            //     类的无法调整大小的新实例。
            //
            // 参数:
            //   buffer:
            //     从中创建此流的无符号字节的数组。
            //
            //   writable:
            //     System.IO.MemoryStream.CanWrite 属性的设置,确定该流是否支持写入。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     buffer 为 null。
            public MemoryStream(byte[] buffer, bool writable);
            //
            // 摘要:
            //     基于字节数组的指定区域(索引)初始化 System.IO.MemoryStream 类的无法调整大小的新实例。
            //
            // 参数:
            //   buffer:
            //     从中创建此流的无符号字节的数组。
            //
            //   index:
            //     buffer 内的索引,流从此处开始。
            //
            //   count:
            //     流的长度(以字节为单位)。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     buffer 为 null。
            //
            //   T:System.ArgumentOutOfRangeException:
            //     index 或 count 小于零。
            //
            //   T:System.ArgumentException:
            //     缓冲区长度减去 index 小于 count。
            public MemoryStream(byte[] buffer, int index, int count);
            //
            // 摘要:
            //     在 System.IO.MemoryStream.CanWrite 属性按指定设置的状态下,基于字节数组的指定区域,初始化 System.IO.MemoryStream
            //     类的无法调整大小的新实例。
            //
            // 参数:
            //   buffer:
            //     从中创建此流的无符号字节的数组。
            //
            //   index:
            //     buffer 内的索引,流从此处开始。
            //
            //   count:
            //     流的长度(以字节为单位)。
            //
            //   writable:
            //     System.IO.MemoryStream.CanWrite 属性的设置,确定该流是否支持写入。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     buffer 为 null。
            //
            //   T:System.ArgumentOutOfRangeException:
            //     index 或 count 为负。
            //
            //   T:System.ArgumentException:
            //     缓冲区长度减去 index 小于 count。
            public MemoryStream(byte[] buffer, int index, int count, bool writable);
            //
            // 摘要:
            //     在 System.IO.MemoryStream.CanWrite 属性和调用 System.IO.MemoryStream.GetBuffer 的能力按指定设置的状态下,基于字节数组的指定区域初始化
            //     System.IO.MemoryStream 类的新实例。
            //
            // 参数:
            //   buffer:
            //     从中创建此流的无符号字节的数组。
            //
            //   index:
            //     buffer 内的索引,流从此处开始。
            //
            //   count:
            //     流的长度(以字节为单位)。
            //
            //   writable:
            //     System.IO.MemoryStream.CanWrite 属性的设置,确定该流是否支持写入。
            //
            //   publiclyVisible:
            //     设置为 true 可以启用 System.IO.MemoryStream.GetBuffer,它返回无符号字节数组,流从该数组创建;否则为 false。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     buffer 为 null。
            //
            //   T:System.ArgumentOutOfRangeException:
            //     index 或 count 为负数。
            //
            //   T:System.ArgumentException:
            //     缓冲区长度减去 index 小于 count。
            public MemoryStream(byte[] buffer, int index, int count, bool writable, bool publiclyVisible);
    
            //
            // 摘要:
            //     获取或设置分配给该流的字节数。
            //
            // 返回结果:
            //     流的缓冲区的可使用部分的长度。
            //
            // 异常:
            //   T:System.ArgumentOutOfRangeException:
            //     容量设置为负或小于该流的当前长度。
            //
            //   T:System.ObjectDisposedException:
            //     当前流已关闭。
            //
            //   T:System.NotSupportedException:
            //     set 调用不能修改其容量的流。
            public virtual int Capacity { get; set; }
            //
            // 摘要:
            //     获取一个值,该值指示当前流是否支持写入。
            //
            // 返回结果:
            //     如果流支持写入,则为 true;否则为 false。
            public override bool CanWrite { get; }
            //
            // 摘要:
            //     获取一个值,该值指示当前流是否支持查找。
            //
            // 返回结果:
            //     如果流是打开的,则为 true。
            public override bool CanSeek { get; }
            //
            // 摘要:
            //     获取一个值,该值指示当前流是否支持读取。
            //
            // 返回结果:
            //     如果流是打开的,则为 true。
            public override bool CanRead { get; }
            //
            // 摘要:
            //     获取流的长度(以字节为单位)。
            //
            // 返回结果:
            //     流的长度(以字节为单位)。
            //
            // 异常:
            //   T:System.ObjectDisposedException:
            //     流已关闭。
            public override long Length { get; }
            //
            // 摘要:
            //     获取或设置流中的当前位置。
            //
            // 返回结果:
            //     流中的当前位置。
            //
            // 异常:
            //   T:System.ArgumentOutOfRangeException:
            //     位置设置为负数值或一个值大于 System.Int32.MaxValue。
            //
            //   T:System.ObjectDisposedException:
            //     流已关闭。
            public override long Position { get; set; }
    
            //
            // 摘要:
            //     使用指定的缓冲区大小和取消令牌,从当前流中异步读取所有字节并将其写入到另一个流中。
            //
            // 参数:
            //   destination:
            //     当前流的内容将复制到的流。
            //
            //   bufferSize:
            //     缓冲区的大小(以字节为单位)。 此值必须大于零。
            //
            //   cancellationToken:
            //     要监视取消请求的标记。
            //
            // 返回结果:
            //     表示异步复制操作的任务。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     destination 为 null。
            //
            //   T:System.ArgumentOutOfRangeException:
            //     buffersize 为负数或零。
            //
            //   T:System.ObjectDisposedException:
            //     已释放当前的流或目标流。
            //
            //   T:System.NotSupportedException:
            //     当前的流不支持读取,或目标流不支持写入。
            public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken);
            //
            // 摘要:
            //     重写 System.IO.Stream.Flush 方法以便不执行任何操作。
            public override void Flush();
            //
            // 摘要:
            //     异步清除此流的所有缓冲区,并监视取消请求。
            //
            // 参数:
            //   cancellationToken:
            //     要监视取消请求的标记。
            //
            // 返回结果:
            //     表示异步刷新操作的任务。
            //
            // 异常:
            //   T:System.ObjectDisposedException:
            //     已释放流。
            [ComVisible(false)]
            public override Task FlushAsync(CancellationToken cancellationToken);
            //
            // 摘要:
            //     返回从中创建此流的无符号字节的数组。
            //
            // 返回结果:
            //     创建此流所用的字节数组;或者如果在当前实例的构造期间没有向 System.IO.MemoryStream 构造函数提供字节数组,则为基础数组。
            //
            // 异常:
            //   T:System.UnauthorizedAccessException:
            //     MemoryStream 实例不用公共可见缓冲区创建。
            [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
            public virtual byte[] GetBuffer();
            //
            // 摘要:
            //     从当前流中读取字节块并将数据写入缓冲区。
            //
            // 参数:
            //   buffer:
            //     当此方法返回时,包含指定的字节数组,该数组中从 offset 到 (offset + count -1) 之间的值由从当前流中读取的字符替换。
            //
            //   offset:
            //     buffer 中的从零开始的字节偏移量,从此处开始存储当前流中的数据。
            //
            //   count:
            //     最多读取的字节数。
            //
            // 返回结果:
            //     写入缓冲区中的总字节数。 如果字节数当前不可用,则总字节数可能小于所请求的字节数;如果在读取到任何字节前已到达流结尾,则为零。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     buffer 为 null。
            //
            //   T:System.ArgumentOutOfRangeException:
            //     offset 或 count 为负数。
            //
            //   T:System.ArgumentException:
            //     offset 从缓冲区长度减去小于比 count。
            //
            //   T:System.ObjectDisposedException:
            //     关闭当前的流实例。
            public override int Read(byte[] buffer, int offset, int count);
            //
            // 摘要:
            //     从当前流异步读取字节的序列,将流中的位置提升读取的字节数,并监视取消请求。
            //
            // 参数:
            //   buffer:
            //     数据写入的缓冲区。
            //
            //   offset:
            //     buffer 中的字节偏移量,从该偏移量开始写入从流中读取的数据。
            //
            //   count:
            //     最多读取的字节数。
            //
            //   cancellationToken:
            //     要监视取消请求的标记。 默认值为 System.Threading.CancellationToken.None。
            //
            // 返回结果:
            //     表示异步读取操作的任务。TResult 参数的值包含读入缓冲区的总字节数。 如果当前可用字节数少于所请求的字节数,则该结果值可小于所请求的字节数;如果已到达流结尾时,则为
            //     0(零)。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     buffer 为 null。
            //
            //   T:System.ArgumentOutOfRangeException:
            //     offset 或 count 为负数。
            //
            //   T:System.ArgumentException:
            //     offset 和 count 的总和大于缓冲区长度。
            //
            //   T:System.NotSupportedException:
            //     流不支持读取。
            //
            //   T:System.ObjectDisposedException:
            //     已释放流。
            //
            //   T:System.InvalidOperationException:
            //     之前的读取操作当前正在使用流。
            [ComVisible(false)]
            public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
            //
            // 摘要:
            //     从当前流中读取一个字节。
            //
            // 返回结果:
            //     强制转换为 System.Int32 的字节;或者如果已到达流的末尾,则为 -1。
            //
            // 异常:
            //   T:System.ObjectDisposedException:
            //     关闭当前的流实例。
            public override int ReadByte();
            //
            // 摘要:
            //     将当前流中的位置设置为指定值。
            //
            // 参数:
            //   offset:
            //     流内的新位置。 它是相对于 loc 参数的位置,而且可正可负。
            //
            //   loc:
            //     类型 System.IO.SeekOrigin 的值,它用作查找引用点。
            //
            // 返回结果:
            //     流内的新位置,通过将初始引用点和偏移量合并计算而得。
            //
            // 异常:
            //   T:System.IO.IOException:
            //     试图在流的开始位置之前进行查找。
            //
            //   T:System.ArgumentOutOfRangeException:
            //     offset 大于 System.Int32.MaxValue。
            //
            //   T:System.ArgumentException:
            //     存在无效 System.IO.SeekOrigin。- 或 -offset 导致算术溢出。
            //
            //   T:System.ObjectDisposedException:
            //     关闭当前的流实例。
            public override long Seek(long offset, SeekOrigin loc);
            //
            // 摘要:
            //     将当前流的长度设为指定值。
            //
            // 参数:
            //   value:
            //     用于设置长度的值。
            //
            // 异常:
            //   T:System.NotSupportedException:
            //     当前流不可调整大小和 value 大于当前容量。- 或 - 当前的流不支持写入。
            //
            //   T:System.ArgumentOutOfRangeException:
            //     value 为负或超过最大长度的概率大于 System.IO.MemoryStream, ,其中的最大长度是 (System.Int32.MaxValue
            //     的原点),源是到基础流开始的缓冲区的索引。
            public override void SetLength(long value);
            //
            // 摘要:
            //     将流内容写入字节数组,而与 System.IO.MemoryStream.Position 属性无关。
            //
            // 返回结果:
            //     新的字节数组。
            public virtual byte[] ToArray();
            //
            // 摘要:
            //     使用从缓冲区读取的数据将字节块写入当前流。
            //
            // 参数:
            //   buffer:
            //     从中写入数据的缓冲区。
            //
            //   offset:
            //     buffer 中的从零开始的字节偏移量,从此处开始将字节复制到当前流。
            //
            //   count:
            //     最多写入的字节数。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     buffer 为 null。
            //
            //   T:System.NotSupportedException:
            //     流不支持写入。 有关更多信息请参阅 System.IO.Stream.CanWrite。- 或 - 当前的位置是比更接近 count 个字节写入流和容量的末尾不能修改。
            //
            //   T:System.ArgumentException:
            //     offset 从缓冲区长度减去小于比 count。
            //
            //   T:System.ArgumentOutOfRangeException:
            //     offset 或 count 为负。
            //
            //   T:System.IO.IOException:
            //     出现 I/O 错误。
            //
            //   T:System.ObjectDisposedException:
            //     关闭当前的流实例。
            public override void Write(byte[] buffer, int offset, int count);
            //
            // 摘要:
            //     将字节的序列异步写入当前流,将该流中的当前位置向前移动写入的字节数,并监视取消请求。
            //
            // 参数:
            //   buffer:
            //     从中写入数据的缓冲区。
            //
            //   offset:
            //     buffer 中的从零开始的字节偏移量,从此处开始将字节复制到该流。
            //
            //   count:
            //     最多写入的字节数。
            //
            //   cancellationToken:
            //     要监视取消请求的标记。 默认值为 System.Threading.CancellationToken.None。
            //
            // 返回结果:
            //     表示异步写入操作的任务。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     buffer 为 null。
            //
            //   T:System.ArgumentOutOfRangeException:
            //     offset 或 count 为负数。
            //
            //   T:System.ArgumentException:
            //     offset 和 count 的总和大于缓冲区长度。
            //
            //   T:System.NotSupportedException:
            //     流不支持写入。
            //
            //   T:System.ObjectDisposedException:
            //     已释放流。
            //
            //   T:System.InvalidOperationException:
            //     流正在由前一次写操作使用。
            [ComVisible(false)]
            public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
            //
            // 摘要:
            //     将一个字节写入当前位置上的当前流。
            //
            // 参数:
            //   value:
            //     要写入的字节。
            //
            // 异常:
            //   T:System.NotSupportedException:
            //     流不支持写入。 有关更多信息请参阅 System.IO.Stream.CanWrite。- 或 - 当前位置位于流的结尾,不能修改容量。
            //
            //   T:System.ObjectDisposedException:
            //     当前流已关闭。
            public override void WriteByte(byte value);
            //
            // 摘要:
            //     将此内存流的整个内容写入到另一个流中。
            //
            // 参数:
            //   stream:
            //     要写入此内存流的流。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     stream 为 null。
            //
            //   T:System.ObjectDisposedException:
            //     当前或目标流已关闭。
            public virtual void WriteTo(Stream stream);
            //
            // 摘要:
            //     释放 System.IO.MemoryStream 类使用的非托管资源,并可以选择释放托管资源。
            //
            // 参数:
            //   disposing:
            //     若要释放托管资源和非托管资源,则为 true;若仅释放非托管资源,则为 false。
            protected override void Dispose(bool disposing);
        }
    }
    2、
    2.返回顶部
     
    3.返回顶部
     
    4.返回顶部
     
    5.返回顶部
     
     
    6.返回顶部
     
    warn 作者:ylbtech
    出处:http://ylbtech.cnblogs.com/
    本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利。
  • 相关阅读:
    5.单表查询
    3.数据类型1
    3.数据类型2
    mysql用户操作和权限管理
    【剑指Offer】面试题27. 二叉树的镜像
    【LeetCode】160. 相交链表
    【剑指Offer】面试题52. 两个链表的第一个公共节点
    【LeetCode】206. 反转链表
    【剑指Offer】面试题24. 反转链表
    LeetCode题解分类汇总(包括剑指Offer和程序员面试金典,持续更新)
  • 原文地址:https://www.cnblogs.com/storebook/p/9504203.html
Copyright © 2020-2023  润新知