namespace System.IO
{
    // 摘要:
    //     提供字节序列的一般视图。
    [Serializable]
    [ComVisible(true)]
    public abstract class Stream : MarshalByRefObject, IDisposable
    {
        // 摘要:
        //     无后备存储区的 Stream。
        public static readonly Stream Null;

        // 摘要:
        //     初始化 System.IO.Stream 类的新实例。
        protected Stream();

        // 摘要:
        //     当在派生类中重写时，获取指示当前流是否支持读取的值。
        //
        // 返回结果:
        //     如果流支持读取，为 true；否则为 false。
        public abstract bool CanRead { get; }
        //
        // 摘要:
        //     当在派生类中重写时，获取指示当前流是否支持查找功能的值。
        //
        // 返回结果:
        //     如果流支持查找，为 true；否则为 false。
        public abstract bool CanSeek { get; }
        //
        // 摘要:
        //     获取一个值，该值确定当前流是否可以超时。
        //
        // 返回结果:
        //     一个确定当前流是否可以超时的值。
        [ComVisible(false)]
        public virtual bool CanTimeout { get; }
        //
        // 摘要:
        //     当在派生类中重写时，获取指示当前流是否支持写入功能的值。
        //
        // 返回结果:
        //     如果流支持写入，为 true；否则为 false。
        public abstract bool CanWrite { get; }
        //
        // 摘要:
        //     当在派生类中重写时，获取用字节表示的流长度。
        //
        // 返回结果:
        //     用字节表示流长度的长值。
        public abstract long Length { get; }
        //
        // 摘要:
        //     当在派生类中重写时，获取或设置当前流中的位置。
        //
        // 返回结果:
        //     流中的当前位置。
        public abstract long Position { get; set; }
        //
        // 摘要:
        //     获取或设置一个值，该值确定流在超时前尝试读取多长时间。
        //
        // 返回结果:
        //     一个确定流在超时前尝试读取多长时间的值。
        [ComVisible(false)]
        public virtual int ReadTimeout { get; set; }
        //
        // 摘要:
        //     获取或设置一个值，该值确定流在超时前尝试写入多长时间。
        //
        // 返回结果:
        //     一个确定流在超时前尝试写入多长时间的值。
        [ComVisible(false)]
        public virtual int WriteTimeout { get; set; }

        // 摘要:
        //     开始异步读操作。
        //
        // 参数:
        //   offset:
        //     buffer 中的字节偏移量，从该偏移量开始写入从流中读取的数据。
        //
        //   count:
        //     最多读取的字节数。
        //
        //   buffer:
        //     数据读入的缓冲区。
        //
        //   callback:
        //     可选的异步回调，在完成读取时调用。
        //
        //   state:
        //     一个用户提供的对象，它将该特定的异步读取请求与其他请求区别开来。
        //
        // 返回结果:
        //     表示异步读取的 System.IAsyncResult（可能仍处于挂起状态）。
        public virtual IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state);
        //
        // 摘要:
        //     开始异步写操作。
        //
        // 参数:
        //   offset:
        //     buffer 中的字节偏移量，从此处开始写入。
        //
        //   count:
        //     最多写入的字节数。
        //
        //   buffer:
        //     从中写入数据的缓冲区。
        //
        //   callback:
        //     可选的异步回调，在完成写入时调用。
        //
        //   state:
        //     一个用户提供的对象，它将该特定的异步写入请求与其他请求区别开来。
        //
        // 返回结果:
        //     表示异步写入的 IAsyncResult（可能仍处于挂起状态）。
        public virtual IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state);
        //
        // 摘要:
        //     关闭当前流并释放与之关联的所有资源（如套接字和文件句柄）。
        public virtual void Close();
        //
        // 摘要:
        //     分配 System.Threading.WaitHandle 对象。
        //
        // 返回结果:
        //     对已分配的 WaitHandle 的引用。
        [Obsolete(@"CreateWaitHandle will be removed eventually.  Please use ""new ManualResetEvent(false)"" instead.")]
        protected virtual WaitHandle CreateWaitHandle();
        //
        // 摘要:
        //     释放由 System.IO.Stream 使用的所有资源。
        public void Dispose();
        //
        // 摘要:
        //     释放由 System.IO.Stream 占用的非托管资源，还可以另外再释放托管资源。
        //
        // 参数:
        //   disposing:
        //     为 true 则释放托管资源和非托管资源；为 false 则仅释放非托管资源。
        protected virtual void Dispose(bool disposing);
        //
        // 摘要:
        //     等待挂起的异步读取完成。
        //
        // 参数:
        //   asyncResult:
        //     对要完成的挂起异步请求的引用。
        //
        // 返回结果:
        //     从流中读取的字节数，介于零 (0) 和所请求的字节数之间。流仅在流的末尾返回零 (0)，否则应一直阻止到至少有 1 个字节可用为止。
        public virtual int EndRead(IAsyncResult asyncResult);
        //
        // 摘要:
        //     结束异步写操作。
        //
        // 参数:
        //   asyncResult:
        //     对未完成的异步 I/O 请求的引用。
        public virtual void EndWrite(IAsyncResult asyncResult);
        //
        // 摘要:
        //     当在派生类中重写时，将清除该流的所有缓冲区，并使得所有缓冲数据被写入到基础设备。
        public abstract void Flush();
        //
        // 摘要:
        //     当在派生类中重写时，从当前流读取字节序列，并将此流中的位置提升读取的字节数。
        //
        // 参数:
        //   offset:
        //     buffer 中的从零开始的字节偏移量，从此处开始存储从当前流中读取的数据。
        //
        //   count:
        //     要从当前流中最多读取的字节数。
        //
        //   buffer:
        //     字节数组。此方法返回时，该缓冲区包含指定的字符数组，该数组的 offset 和 (offset + count -1) 之间的值由从当前源中读取的字节替换。
        //
        // 返回结果:
        //     读入缓冲区中的总字节数。如果当前可用的字节数没有请求的字节数那么多，则总字节数可能小于请求的字节数，或者如果已到达流的末尾，则为零 (0)。
        public abstract int Read(byte[] buffer, int offset, int count);
        //
        // 摘要:
        //     从流中读取一个字节，并将流内的位置向前推进一个字节，或者如果已到达流的末尾，则返回 -1。
        //
        // 返回结果:
        //     转换为 Int32 的无符号字节，或者如果到达流的末尾，则为 -1。
        public virtual int ReadByte();
        //
        // 摘要:
        //     当在派生类中重写时，设置当前流中的位置。
        //
        // 参数:
        //   offset:
        //     相对于 origin 参数的字节偏移量。
        //
        //   origin:
        //     System.IO.SeekOrigin 类型的值，指示用于获取新位置的参考点。
        //
        // 返回结果:
        //     当前流中的新位置。
        public abstract long Seek(long offset, SeekOrigin origin);
        //
        // 摘要:
        //     当在派生类中重写时，设置当前流的长度。
        //
        // 参数:
        //   value:
        //     所需的当前流的长度（以字节表示）。
        public abstract void SetLength(long value);
        //
        // 摘要:
        //     在指定的 System.IO.Stream 对象周围创建线程安全（同步）包装。
        //
        // 参数:
        //   stream:
        //     要同步的 System.IO.Stream 对象。
        //
        // 返回结果:
        //     一个线程安全的 System.IO.Stream 对象。
        public static Stream Synchronized(Stream stream);
        //
        // 摘要:
        //     当在派生类中重写时，向当前流中写入字节序列，并将此流中的当前位置提升写入的字节数。
        //
        // 参数:
        //   offset:
        //     buffer 中的从零开始的字节偏移量，从此处开始将字节复制到当前流。
        //
        //   count:
        //     要写入当前流的字节数。
        //
        //   buffer:
        //     字节数组。此方法将 count 个字节从 buffer 复制到当前流。
        public abstract void Write(byte[] buffer, int offset, int count);
        //
        // 摘要:
        //     将一个字节写入流内的当前位置，并将流内的位置向前推进一个字节。
        //
        // 参数:
        //   value:
        //     要写入流的字节。
        public virtual void WriteByte(byte value);
    }
}
上述是一个抽象类stream的定义.对于这个类我主要有一个不明白的地方
1.public static Stream Synchronized(Stream stream);
抽象类是不能不实例的,为什么返回类型可以是stream,返回值不是要一个实体么?
而且用return也不能返回stream