c# - crear - MemoryStream tiene un hilo de escritura y otro de lectura.

memorystream to stream c#

Question

Así es como escribo en una secuencia y luego leo de ella usando 1 secuencia:

 System.IO.MemoryStream ms = new System.IO.MemoryStream();
// write to it
ms.Write(new byte[] { 1, 2, 3, 4, 5, 6, 7 }, 0, 7);
// go to the begining
ms.Seek(0, System.IO.SeekOrigin.Begin);
// now read from it
byte[] myBuffer = new byte[7];
ms.Read(myBuffer, 0, 7);

Ahora me preguntaba si es posible escribir en el flujo de memoria desde un hilo y leer ese flujo desde un hilo separado.

Answer 1

No puede usar un Stream con capacidades de búsqueda de 2 subprocesos simultáneamente ya que un Stream está lleno. por ejemplo, un NetworkStream tiene 2 canales, uno para leer y otro para escribir y, por lo tanto, no admite la búsqueda.

Si necesita buscar capacidades, necesita crear 2 secuencias, una para leer y otra para escribir respectivamente. De lo contrario, puede simplemente crear un nuevo tipo de secuencia que permita leer y escribir desde una secuencia de memoria subyacente al tener acceso exclusivo a la secuencia subyacente y restaurar su posición de escritura / lectura. Un ejemplo primitivo de eso sería:

class ProducerConsumerStream : Stream
{
private readonly MemoryStream innerStream;
private long readPosition;
private long writePosition;
public ProducerConsumerStream()
{
innerStream = new MemoryStream();
}
public override bool CanRead { get { return true; } }
public override bool CanSeek { get { return false; } }
public override bool CanWrite { get { return true; } }
public override void Flush()
{
lock (innerStream)
{
innerStream.Flush();
}
}
public override long Length
{
get
{
lock (innerStream)
{
return innerStream.Length;
}
}
}
public override long Position
{
get { throw new NotSupportedException(); }
set { throw new NotSupportedException(); }
}
public override int Read(byte[] buffer, int offset, int count)
{
lock (innerStream)
{
innerStream.Position = readPosition;
int red = innerStream.Read(buffer, offset, count);
readPosition = innerStream.Position;
return red;
}
}
public override long Seek(long offset, SeekOrigin origin)
{
throw new NotSupportedException();
}
public override void SetLength(long value)
{
throw new NotImplementedException();
}
public override void Write(byte[] buffer, int offset, int count)
{
lock (innerStream)
{
innerStream.Position = writePosition;
innerStream.Write(buffer, offset, count);
writePosition = innerStream.Position;
}
}
}