是否可以在C＃中設置NetworkStream對象的CanRead和CanWrite屬性？

Question

我要創建兩個NetworkStreams對象，我想一個人應該只支持閱讀操作，另一種只有書面方式操作。這就是我試圖做的，但我得到了錯誤

NetworkStream nStreamObj1 = new NetworkStream(clientSocket); 
    NetworkStream nStreamObj2 = new NetworkStream(clientSocket); 

    nStreamObj1.canRead = true; 
    nStreamObj1.canWrite = false 

    nStreamObj1.canRead = false; 
    nStreamObj1.canWrite = true; 

我得到的錯誤和的CanRead是CanWrite只讀屬性！我如何設置這些屬性？

Answer 1

假設的Socket可以讀寫，你可以嘗試以下方法：

NetworkStream nStreamObj1 = new NetworkStream(clientSocket, FileAccess.Read); 
NetworkStream nStreamObj2 = new NetworkStream(clientSocket, FileAccess.Write); 

編輯：

見備註部分here

Answer 2

您無法設置這些值。它們將取決於創建此網絡流的底層套接字的狀態。

Answer 3

在構造函數中設置提供相應的FileAccess枚舉值NetworkStream的可讀性和可寫性。 CanRead屬性在NetworkStream初始化時設置。

所以你不能直接設置這些值。

Answer 4

如果無法調用NetworkStream構造函數（也許是流調用TcpClient.GetStream的結果），你唯一的選擇將是使該覆蓋CanRead/CanWrite性能的包裝流。它可能是這個樣子：

public class ReadOrWriteStream:Stream 
{ 
    private readonly Stream srcStream; 
    private readonly bool canRead; 
    private readonly bool canWrite; 
    private bool disposed; 

    public ReadOrWriteStream(Stream srcStream, bool canRead, bool canWrite) 
    { 
     this.disposed = false; 
     this.srcStream = srcStream; 
     this.canRead = canRead; 
     this.canWrite = canWrite; 
    } 

    public override void Flush() 
    { 
     srcStream.Flush(); 
    } 

    public override long Seek(long offset, SeekOrigin origin) 
    { 
     return srcStream.Seek(offset, 
           origin); 
    } 

    public override void SetLength(long value) 
    { 
     if (!CanWrite) 
      throw new NotSupportedException(); 
     srcStream.SetLength(value); 
    } 

    public override int Read(byte[] buffer, int offset, int count) 
    { 
     if(!CanRead) 
      throw new NotSupportedException(); 
     return srcStream.Read(buffer, 
           offset, 
           count); 
    } 

    public override void Write(byte[] buffer, int offset, int count) 
    { 
     if(!CanWrite)     
      throw new NotSupportedException(); 
     srcStream.Write(buffer, 
           offset, 
           count); 

    } 

    public override bool CanRead 
    { 
     get 
     { 
      return srcStream.CanRead && canRead; 
     } 
    } 

    public override bool CanSeek 
    { 
     get 
     { 
      return srcStream.CanSeek; 
     } 
    } 

    public override bool CanWrite 
    { 
     get 
     { 
      return srcStream.CanWrite && canWrite; 
     } 
    } 

    public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state) 
    { 
     if(!CanRead) 
      throw new NotSupportedException(); 
     return srcStream.BeginRead(buffer, 
            offset, 
            count, 
            callback, 
            state); 
    } 

    public override int EndRead(IAsyncResult asyncResult) 
    { 
     return srcStream.EndRead(asyncResult); 
    } 

    public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state) 
    { 
     if (!CanWrite) 
      throw new NotSupportedException(); 
     return srcStream.BeginWrite(buffer, 
            offset, 
            count, 
            callback, 
            state); 
    } 

    public override void EndWrite(IAsyncResult asyncResult) 
    { 
     srcStream.EndWrite(asyncResult); 
    } 

    public override long Length 
    { 
     get 
     { 
      return srcStream.Length; 
     } 
    } 

    public override long Position 
    { 
     get 
     { 
      return srcStream.Position; 
     } 
     set 
     { 
      srcStream.Position = value; 
     } 
    } 

    protected override void Dispose(bool disposing) 
    { 
     if(disposing && !disposed) 
     { 
      srcStream.Dispose(); 
      disposed = true; 
     } 
     base.Dispose(disposing); 
    } 

} 

所以：

var networkStream = myTcpClient.GetStream(); 
var readOnlyStream = new ReadOrWriteStream(networkStream, true, false); 
var writeOnlyStream = new ReadOrWriteStream(networkStream, false, true);