zoukankan      html  css  js  c++  java
  • System.IO.Stream.cs

    ylbtech-System.IO.Stream.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 abstract class Stream : MarshalByRefObject, IDisposable
        {
            //
            // 摘要:
            //     无后备存储区的 Stream。
            public static readonly Stream Null;
    
            //
            // 摘要:
            //     初始化 System.IO.Stream 类的新实例。
            protected Stream();
    
            //
            // 摘要:
            //     当在派生类中重写时,获取或设置当前流中的位置。
            //
            // 返回结果:
            //     流中的当前位置。
            //
            // 异常:
            //   T:System.IO.IOException:
            //     出现 I/O 错误。
            //
            //   T:System.NotSupportedException:
            //     流不支持查找。
            //
            //   T:System.ObjectDisposedException:
            //     在流关闭后调用方法。
            public abstract long Position { get; set; }
            //
            // 摘要:
            //     当在派生类中重写时,获取流长度(以字节为单位)。
            //
            // 返回结果:
            //     表示流长度(以字节为单位)的长值。
            //
            // 异常:
            //   T:System.NotSupportedException:
            //     从派生的类 Stream 不支持查找。
            //
            //   T:System.ObjectDisposedException:
            //     在流关闭后调用方法。
            public abstract long Length { get; }
            //
            // 摘要:
            //     当在派生类中重写时,获取指示当前流是否支持写入功能的值。
            //
            // 返回结果:
            //     如果流支持写入,则为 true;否则为 false。
            public abstract bool CanWrite { get; }
            //
            // 摘要:
            //     获取一个值,该值确定当前流是否可以超时。
            //
            // 返回结果:
            //     一个确定当前流是否可以超时的值。
            [ComVisible(false)]
            public virtual bool CanTimeout { get; }
            //
            // 摘要:
            //     当在派生类中重写时,获取指示当前流是否支持查找功能的值。
            //
            // 返回结果:
            //     如果流支持查找,为 true;否则为 false。
            public abstract bool CanSeek { get; }
            //
            // 摘要:
            //     当在派生类中重写时,获取指示当前流是否支持读取的值。
            //
            // 返回结果:
            //     如果流支持读取,为 true;否则为 false。
            public abstract bool CanRead { get; }
            //
            // 摘要:
            //     获取或设置一个值(以毫秒为单位),该值确定流在超时前尝试读取多长时间。
            //
            // 返回结果:
            //     一个确定流在超时前尝试读取多长时间的值(以毫秒为单位)。
            //
            // 异常:
            //   T:System.InvalidOperationException:
            //     System.IO.Stream.ReadTimeout 方法始终引发 System.InvalidOperationException。
            [ComVisible(false)]
            public virtual int ReadTimeout { get; set; }
            //
            // 摘要:
            //     获取或设置一个值(以毫秒为单位),该值确定流在超时前尝试写入多长时间。
            //
            // 返回结果:
            //     一个确定流在超时前尝试写入多长时间的值(以毫秒为单位)。
            //
            // 异常:
            //   T:System.InvalidOperationException:
            //     System.IO.Stream.WriteTimeout 方法始终引发 System.InvalidOperationException。
            [ComVisible(false)]
            public virtual int WriteTimeout { get; set; }
    
            //
            // 摘要:
            //     在指定的 System.IO.Stream 对象周围创建线程安全(同步)包装。
            //
            // 参数:
            //   stream:
            //     要同步的 System.IO.Stream 对象。
            //
            // 返回结果:
            //     一个线程安全的 System.IO.Stream 对象。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     stream 为 null。
            public static Stream Synchronized(Stream stream);
            //
            // 摘要:
            //     开始异步读操作。 (考虑使用 System.IO.Stream.ReadAsync(System.Byte[],System.Int32,System.Int32)
            //     进行替换;请参见“备注”部分。)
            //
            // 参数:
            //   buffer:
            //     数据读入的缓冲区。
            //
            //   offset:
            //     buffer 中的字节偏移量,从该偏移量开始写入从流中读取的数据。
            //
            //   count:
            //     最多读取的字节数。
            //
            //   callback:
            //     可选的异步回调,在完成读取时调用。
            //
            //   state:
            //     一个用户提供的对象,它将该特定的异步读取请求与其他请求区别开来。
            //
            // 返回结果:
            //     表示异步读取的 System.IAsyncResult(可能仍处于挂起状态)。
            //
            // 异常:
            //   T:System.IO.IOException:
            //     尝试超出末尾的流中的异步读取或发生了磁盘错误。
            //
            //   T:System.ArgumentException:
            //     一个或多个参数无效。
            //
            //   T:System.ObjectDisposedException:
            //     在流关闭后调用方法。
            //
            //   T:System.NotSupportedException:
            //     当前 Stream 实现不支持读取的操作。
            public virtual IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state);
            //
            // 摘要:
            //     开始异步写操作。 (考虑使用 System.IO.Stream.WriteAsync(System.Byte[],System.Int32,System.Int32)
            //     进行替换;请参见“备注”部分。)
            //
            // 参数:
            //   buffer:
            //     从中写入数据的缓冲区。
            //
            //   offset:
            //     buffer 中的字节偏移量,从此处开始写入。
            //
            //   count:
            //     最多写入的字节数。
            //
            //   callback:
            //     可选的异步回调,在完成写入时调用。
            //
            //   state:
            //     一个用户提供的对象,它将该特定的异步写入请求与其他请求区别开来。
            //
            // 返回结果:
            //     表示异步写入的 IAsyncResult(可能仍处于挂起状态)。
            //
            // 异常:
            //   T:System.IO.IOException:
            //     尝试异步写入该流的末尾,或者发生了磁盘错误。
            //
            //   T:System.ArgumentException:
            //     一个或多个参数无效。
            //
            //   T:System.ObjectDisposedException:
            //     在流关闭后调用方法。
            //
            //   T:System.NotSupportedException:
            //     当前 Stream 实现不支持写入操作。
            public virtual IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state);
            //
            // 摘要:
            //     关闭当前流并释放与之关联的所有资源(如套接字和文件句柄)。 不直接调用此方法,而应确保流得以正确释放。
            public virtual void Close();
            //
            // 摘要:
            //     从当前流中读取字节并将其写入到另一流中。
            //
            // 参数:
            //   destination:
            //     当前流的内容将复制到的流。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     destination 为 null。
            //
            //   T:System.NotSupportedException:
            //     当前流不支持读取。- 或 -destination 不支持写入。
            //
            //   T:System.ObjectDisposedException:
            //     当前流或 destination 之前关闭 System.IO.Stream.CopyTo(System.IO.Stream) 方法被调用。
            //
            //   T:System.IO.IOException:
            //     出现 I/O 错误。
            public void CopyTo(Stream destination);
            //
            // 摘要:
            //     使用指定的缓冲区大小,从当前流中读取字节并将其写入到另一流中。
            //
            // 参数:
            //   destination:
            //     当前流的内容将复制到的流。
            //
            //   bufferSize:
            //     缓冲区的大小。 此值必须大于零。 默认大小为 81920。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     destination 为 null。
            //
            //   T:System.ArgumentOutOfRangeException:
            //     bufferSize 为负数或零。
            //
            //   T:System.NotSupportedException:
            //     当前流不支持读取。- 或 -destination 不支持写入。
            //
            //   T:System.ObjectDisposedException:
            //     当前流或 destination 之前关闭 System.IO.Stream.CopyTo(System.IO.Stream) 方法被调用。
            //
            //   T:System.IO.IOException:
            //     出现 I/O 错误。
            public void CopyTo(Stream destination, int bufferSize);
            //
            // 摘要:
            //     从当前流中异步读取字节并将其写入到另一个流中。
            //
            // 参数:
            //   destination:
            //     当前流的内容将复制到的流。
            //
            // 返回结果:
            //     表示异步复制操作的任务。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     destination 为 null。
            //
            //   T:System.ObjectDisposedException:
            //     已释放当前的流或目标流。
            //
            //   T:System.NotSupportedException:
            //     当前的流不支持读取,或目标流不支持写入。
            [ComVisible(false)]
            public Task CopyToAsync(Stream destination);
            //
            // 摘要:
            //     使用指定的缓冲区大小,从当前流中异步读取字节并将其写入到另一流中。
            //
            // 参数:
            //   destination:
            //     当前流的内容将复制到的流。
            //
            //   bufferSize:
            //     缓冲区的大小(以字节为单位)。 此值必须大于零。 默认大小为 81920。
            //
            // 返回结果:
            //     表示异步复制操作的任务。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     destination 为 null。
            //
            //   T:System.ArgumentOutOfRangeException:
            //     buffersize 为负数或零。
            //
            //   T:System.ObjectDisposedException:
            //     已释放当前的流或目标流。
            //
            //   T:System.NotSupportedException:
            //     当前的流不支持读取,或目标流不支持写入。
            [ComVisible(false)]
            public Task CopyToAsync(Stream destination, int bufferSize);
            //
            // 摘要:
            //     使用指定的缓冲区大小和取消令牌,从当前流中异步读取字节并将其写入到另一个流中。
            //
            // 参数:
            //   destination:
            //     当前流的内容将复制到的流。
            //
            //   bufferSize:
            //     缓冲区的大小(以字节为单位)。 此值必须大于零。 默认大小为 81920。
            //
            //   cancellationToken:
            //     要监视取消请求的标记。 默认值为 System.Threading.CancellationToken.None。
            //
            // 返回结果:
            //     表示异步复制操作的任务。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     destination 为 null。
            //
            //   T:System.ArgumentOutOfRangeException:
            //     buffersize 为负数或零。
            //
            //   T:System.ObjectDisposedException:
            //     已释放当前的流或目标流。
            //
            //   T:System.NotSupportedException:
            //     当前的流不支持读取,或目标流不支持写入。
            [ComVisible(false)]
            public virtual Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken);
            //
            // 摘要:
            //     释放由 System.IO.Stream 使用的所有资源。
            public void Dispose();
            //
            // 摘要:
            //     等待挂起的异步读取完成。 (考虑使用 System.IO.Stream.ReadAsync(System.Byte[],System.Int32,System.Int32)
            //     进行替换;请参见“备注”部分。)
            //
            // 参数:
            //   asyncResult:
            //     对要完成的挂起异步请求的引用。
            //
            // 返回结果:
            //     从流中读取的字节数,介于零 (0) 和所请求的字节数之间。 流仅在流结尾返回零 (0),否则在至少有 1 个字节可用之前应一直进行阻止。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     asyncResult 为 null。
            //
            //   T:System.ArgumentException:
            //     挂起的读操作的句柄将不可用。- 或 -挂起的操作不支持读取。
            //
            //   T:System.InvalidOperationException:
            //     asyncResult 不是源自 System.IO.Stream.BeginRead(System.Byte[],System.Int32,System.Int32,System.AsyncCallback,System.Object)
            //     上当前流的方法。
            //
            //   T:System.IO.IOException:
            //     流已关闭或出现了内部错误。
            public virtual int EndRead(IAsyncResult asyncResult);
            //
            // 摘要:
            //     结束异步写操作。 (考虑使用 System.IO.Stream.WriteAsync(System.Byte[],System.Int32,System.Int32)
            //     进行替换;请参见“备注”部分。)
            //
            // 参数:
            //   asyncResult:
            //     对未完成的异步 I/O 请求的引用。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     asyncResult 为 null。
            //
            //   T:System.ArgumentException:
            //     正在等待的写入操作的句柄将不可用。- 或 -挂起的操作不支持写入。
            //
            //   T:System.InvalidOperationException:
            //     asyncResult 不是源自 System.IO.Stream.BeginWrite(System.Byte[],System.Int32,System.Int32,System.AsyncCallback,System.Object)
            //     上当前流的方法。
            //
            //   T:System.IO.IOException:
            //     流已关闭或出现了内部错误。
            public virtual void EndWrite(IAsyncResult asyncResult);
            //
            // 摘要:
            //     当在派生类中重写时,将清除该流的所有缓冲区,并使得所有缓冲数据被写入到基础设备。
            //
            // 异常:
            //   T:System.IO.IOException:
            //     出现 I/O 错误。
            public abstract void Flush();
            //
            // 摘要:
            //     异步清除此流的所有缓冲区并导致所有缓冲数据都写入基础设备中。
            //
            // 返回结果:
            //     表示异步刷新操作的任务。
            //
            // 异常:
            //   T:System.ObjectDisposedException:
            //     已释放流。
            [ComVisible(false)]
            public Task FlushAsync();
            //
            // 摘要:
            //     异步清理这个流的所有缓冲区,并使所有缓冲数据写入基础设备,并且监控取消请求。
            //
            // 参数:
            //   cancellationToken:
            //     要监视取消请求的标记。 默认值为 System.Threading.CancellationToken.None。
            //
            // 返回结果:
            //     表示异步刷新操作的任务。
            //
            // 异常:
            //   T:System.ObjectDisposedException:
            //     已释放流。
            [ComVisible(false)]
            public virtual Task FlushAsync(CancellationToken cancellationToken);
            //
            // 摘要:
            //     当在派生类中重写时,从当前流读取字节序列,并将此流中的位置提升读取的字节数。
            //
            // 参数:
            //   buffer:
            //     字节数组。 此方法返回时,该缓冲区包含指定的字符数组,该数组的 offset 和 (offset + count -1) 之间的值由从当前源中读取的字节替换。
            //
            //   offset:
            //     buffer 中的从零开始的字节偏移量,从此处开始存储从当前流中读取的数据。
            //
            //   count:
            //     要从当前流中最多读取的字节数。
            //
            // 返回结果:
            //     读入缓冲区中的总字节数。 如果很多字节当前不可用,则总字节数可能小于请求的字节数;如果已到达流结尾,则为零 (0)。
            //
            // 异常:
            //   T:System.ArgumentException:
            //     offset 和 count 的总和大于缓冲区长度。
            //
            //   T:System.ArgumentNullException:
            //     buffer 为 null。
            //
            //   T:System.ArgumentOutOfRangeException:
            //     offset 或 count 为负数。
            //
            //   T:System.IO.IOException:
            //     出现 I/O 错误。
            //
            //   T:System.NotSupportedException:
            //     流不支持读取。
            //
            //   T:System.ObjectDisposedException:
            //     在流关闭后调用方法。
            public abstract 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 virtual Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
            //
            // 摘要:
            //     从当前流异步读取字节序列,并将流中的位置提升读取的字节数。
            //
            // 参数:
            //   buffer:
            //     数据写入的缓冲区。
            //
            //   offset:
            //     buffer 中的字节偏移量,从该偏移量开始写入从流中读取的数据。
            //
            //   count:
            //     最多读取的字节数。
            //
            // 返回结果:
            //     表示异步读取操作的任务。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 Task<int> ReadAsync(byte[] buffer, int offset, int count);
            //
            // 摘要:
            //     从流中读取一个字节,并将流内的位置向前提升一个字节,或者如果已到达流结尾,则返回 -1。
            //
            // 返回结果:
            //     强制转换为 Int32 的无符号字节,如果到达流的末尾,则为 -1。
            //
            // 异常:
            //   T:System.NotSupportedException:
            //     流不支持读取。
            //
            //   T:System.ObjectDisposedException:
            //     在流关闭后调用方法。
            [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
            public virtual int ReadByte();
            //
            // 摘要:
            //     当在派生类中重写时,设置当前流中的位置。
            //
            // 参数:
            //   offset:
            //     相对于 origin 参数的字节偏移量。
            //
            //   origin:
            //     System.IO.SeekOrigin 类型的值,指示用于获取新位置的参考点。
            //
            // 返回结果:
            //     当前流中的新位置。
            //
            // 异常:
            //   T:System.IO.IOException:
            //     出现 I/O 错误。
            //
            //   T:System.NotSupportedException:
            //     流不支持查找,例如在流构造从管道或控制台输出的情况下即为如此。
            //
            //   T:System.ObjectDisposedException:
            //     在流关闭后调用方法。
            public abstract long Seek(long offset, SeekOrigin origin);
            //
            // 摘要:
            //     当在派生类中重写时,设置当前流的长度。
            //
            // 参数:
            //   value:
            //     所需的当前流的长度(以字节表示)。
            //
            // 异常:
            //   T:System.IO.IOException:
            //     出现 I/O 错误。
            //
            //   T:System.NotSupportedException:
            //     流不支持写入和查找,例如在流构造从管道或控制台输出的情况下即为如此。
            //
            //   T:System.ObjectDisposedException:
            //     在流关闭后调用方法。
            public abstract void SetLength(long value);
            //
            // 摘要:
            //     当在派生类中重写时,向当前流中写入字节序列,并将此流中的当前位置提升写入的字节数。
            //
            // 参数:
            //   buffer:
            //     字节数组。 此方法将 count 个字节从 buffer 复制到当前流。
            //
            //   offset:
            //     buffer 中的从零开始的字节偏移量,从此处开始将字节复制到当前流。
            //
            //   count:
            //     要写入当前流的字节数。
            //
            // 异常:
            //   T:System.ArgumentException:
            //     总和 offset 和 count 大于缓冲区长度。
            //
            //   T:System.ArgumentNullException:
            //     buffer 是 null。
            //
            //   T:System.ArgumentOutOfRangeException:
            //     offset 或 count 为负。
            //
            //   T:System.IO.IOException:
            //     将出现 I/O 错误,如找不到指定的文件。
            //
            //   T:System.NotSupportedException:
            //     流不支持写入。
            //
            //   T:System.ObjectDisposedException:
            //     System.IO.Stream.Write(System.Byte[],System.Int32,System.Int32) 是关闭了流之后调用。
            public abstract 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 virtual Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
            //
            // 摘要:
            //     将字节序列异步写入当前流,并将流的当前位置提升写入的字节数。
            //
            // 参数:
            //   buffer:
            //     从中写入数据的缓冲区。
            //
            //   offset:
            //     buffer 中的从零开始的字节偏移量,从此处开始将字节复制到该流。
            //
            //   count:
            //     最多写入的字节数。
            //
            // 返回结果:
            //     表示异步写入操作的任务。
            //
            // 异常:
            //   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 Task WriteAsync(byte[] buffer, int offset, int count);
            //
            // 摘要:
            //     将一个字节写入流内的当前位置,并将流内的位置向前提升一个字节。
            //
            // 参数:
            //   value:
            //     要写入流中的字节。
            //
            // 异常:
            //   T:System.IO.IOException:
            //     出现 I/O 错误。
            //
            //   T:System.NotSupportedException:
            //     流不支持写入,或该流已关闭。
            //
            //   T:System.ObjectDisposedException:
            //     在流关闭后调用方法。
            public virtual void WriteByte(byte value);
            //
            // 摘要:
            //     分配 System.Threading.WaitHandle 对象。
            //
            // 返回结果:
            //     对已分配的 WaitHandle 的引用。
            [Obsolete("CreateWaitHandle will be removed eventually.  Please use "new ManualResetEvent(false)" instead.")]
            protected virtual WaitHandle CreateWaitHandle();
            //
            // 摘要:
            //     释放由 System.IO.Stream 占用的非托管资源,还可以另外再释放托管资源。
            //
            // 参数:
            //   disposing:
            //     若要释放托管资源和非托管资源,则为 true;若仅释放非托管资源,则为 false。
            protected virtual void Dispose(bool disposing);
            //
            // 摘要:
            //     提供对 System.Diagnostics.Contracts.Contract 的支持。
            [Obsolete("Do not call or override this method.")]
            protected virtual void ObjectInvariant();
        }
    }
    2、
    2.返回顶部
     
    3.返回顶部
     
    4.返回顶部
     
    5.返回顶部
     
     
    6.返回顶部
     
    warn 作者:ylbtech
    出处:http://ylbtech.cnblogs.com/
    本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利。
  • 相关阅读:
    eclipse maven项目 热部署
    二十三. Django ModelForm组件
    二十二 .Django生命周期
    二十二 .Django form上传+Ajax+FormData上传+Form组件上传+序列化+ifram伪造Ajax
    二十一. Django----ajax全部
    二十. Django ajax--请求数据 和模态对话框
    二十. Django分页 和自定义分页
    十九. Django-Cookie的CBV和FBV的用户验证装饰器
    十八 .Django session应用
    十七 .Django cookie应用
  • 原文地址:https://www.cnblogs.com/storebook/p/9504139.html
Copyright © 2011-2022 走看看