问题
When reading data from NetworkStream with ReadUntilClosedObservable1, the returned data is corrupted like some blocks of read data overlap.
However, when I read the data with ReadUntilClosedObservable2 the data arrives without problems.
I want to use the ReadUntilClosedObservable1 because repeatedly reading from stream in ReadUntilClosedObservable2 is burning the CPU.
How can I get the messages in sync order?
UPDATE:
return Observable.Timer(TimeSpan.Zero, interval, TaskPoolScheduler.Default)
.SelectMany(_ => readToEnd)
.Where(dataChunk => dataChunk.Length > 0);
I just noticed that readToEnd to is fired again and again before it finishes the previous job. Doesn't it need to be synchronized? If Observable.Timer is the problem how can I achieve the same effect without it, reading in intervals but starting without waiting?
public static IObservable<int> ReadObservable(this Stream stream, byte[] buffer
,int offset, int count)
{
return stream.ReadAsync(buffer, offset, count)
.ToObservable();
}
public static IObservable<byte[]> ReadObservable(this Stream stream,
int bufferSize)
{
var buffer = new byte[bufferSize];
return stream.ReadObservable(buffer, 0, buffer.Length)
.Select(cbRead =>
{
if (cbRead == 0)
{
return new byte[0];
}
if (cbRead == buffer.Length)
{
return buffer;
}
var dataChunk = new byte[cbRead];
Buffer.BlockCopy(buffer, 0, dataChunk,
0, cbRead);
return dataChunk;
});
}
public static IObservable<byte[]> ReadUntilClosedObservable1(this NetworkStream
stream, int bufferSize, TimeSpan interval)
{
var readToEnd = Observable.Defer(() => stream.ReadObservable(bufferSize))
.DoWhile(() => stream.DataAvailable)
.ToList()
.Select(dataChunks =>
{
var buffer = new List<byte>();
foreach (var dataChunk in dataChunks)
{
buffer.AddRange(dataChunk);
}
return buffer.ToArray();
});
return Observable.Timer(TimeSpan.Zero, interval, TaskPoolScheduler.Default)
.SelectMany(_ => readToEnd)
.Where(dataChunk => dataChunk.Length > 0);
}
public static IObservable<byte[]> ReadUntilClosedObservable2(this Stream stream
,int bufferSize)
{
return Observable.Defer(() => stream.ReadObservable(bufferSize))
.Repeat()
.Where(dataChunk => dataChunk.Length > 0);
}
回答1:
Oh, no, no...don't do it like that...
Async + Rx is one of the more...non-intuitive setups to get working, but it is quite a bit simpler than what you're attempting. The key bits are three different Rx operators:
FromAsyncPattern: generates a "IObservableFactory" from an async call signatureObservable.Defer: allows you to use aboveIObservablefactory to generate observables per subscriberObservable.While: allows you to "Reinvoke until I say when" on anIObservable
(EDIT: altered to use a NetworkStream example)
(doubleEDIT: altered based on comments)
Try this - unless I miss my guess, it's more or less what you're trying for:
void Main()
{
// We'll feed this to listener
var message = "Yo mamma said you like messages like this";
var listenerTask = Task
.Factory
.StartNew(() =>
{
var bufferSize = 1024;
var localhost = new IPAddress(new byte[]{127,0,0,1});
var listener = new TcpListener(localhost, 11201);
listener.Start();
var incomingClient = listener.AcceptTcpClient();
var clientStream = incomingClient.GetStream();
// our buffered reader
var observer = clientStream.ReadObservable(bufferSize);
var compareBuffer = observer
// Take while we're getting data and the client
// is still connected
.TakeWhile(returnBuffer => returnBuffer.Length > 0 &&
incomingClient.Connected)
// In between read blocks, respond back to the client
// No need for fanciness here, just normal async writeback
.Do(returnBuffer => clientStream.BeginWrite(
returnBuffer,
0,
returnBuffer.Length,
ar => clientStream.EndWrite(ar),
null))
.ToEnumerable()
.SelectMany (returnBuffer => returnBuffer)
.ToArray();
listener.Stop();
Console.WriteLine(
"Listener thinks it was told... {0}",
Encoding.ASCII.GetString(compareBuffer));
});
var clientTask = Task.Factory.StartNew(
() =>
{
var client = new TcpClient();
client.Connect("localhost", 11201);
var random = new Random();
var outStream = client.GetStream();
var bytesToSend = Encoding.ASCII.GetBytes(message);
foreach(byte toSend in bytesToSend)
{
// send a character over
outStream.WriteByte(toSend);
// Listener should parrot us...
int goOn = outStream.ReadByte();
if(goOn != toSend)
{
Console.WriteLine(
"Huh. Listener echoed wrong. I said: {0}, they said {1}",
toSend,
goOn);
break;
}
Console.WriteLine("I said: {0}, they said {1}", toSend, goOn);
// Take a little nap (simulate latency, etc)
Thread.Sleep(random.Next(200));
}
client.Close();
});
Task.WaitAll(listenerTask, clientTask);
}
public static class Ext
{
public static IObservable<byte[]> ReadObservable(this Stream stream, int bufferSize)
{
// to hold read data
var buffer = new byte[bufferSize];
// Step 1: async signature => observable factory
var asyncRead = Observable.FromAsyncPattern<byte[], int, int, int>(
stream.BeginRead,
stream.EndRead);
return Observable.While(
// while there is data to be read
() => stream.CanRead,
// iteratively invoke the observable factory, which will
// "recreate" it such that it will start from the current
// stream position - hence "0" for offset
Observable.Defer(() => asyncRead(buffer, 0, bufferSize))
.Select(readBytes => buffer.Take(readBytes).ToArray()));
}
}
来源：https://stackoverflow.com/questions/14439976/reading-from-networkstream-corrupts-the-buffer