Question

我在循环中从客户端向服务器发送10条消息，然后使用TPL的FromAsync（针对.NET 4.0）从服务器回复客户端

在客户端发送最后一条消息后，我试图测量收到最终响应所需的总时间。要做到这一点，我调用Task.WaitAll，但是我得到一个AggregateException，他的内部异常是＆＃34;任务被取消＆＃34;完成所有任务。服务器正在接收请求。

代码：

private static double MeasureAsyncTPL(List<string> stringList)
    {
        var stopwatch = new Stopwatch();
        stopwatch.Start();

        var tasks = new Task[stringList.Count];
        for (int i = 0; i < stringList.Count; i++)
        {
            string source = stringList[i];
            tasks[i] = SendMessageToServerAsync(source);
            //SendMessageToServerAsync(source);
        }
        Task.WaitAll(tasks);


        stopwatch.Stop();            
        return stopwatch.Elapsed.TotalMilliseconds; 
    }

        static Task SendMessageToServerAsync(string message)
    {
        Task task;
        var byteArray = MessageToByteArray(message, Encoding.UTF8);
        using (var tcpClient = new TcpClient())
        {
            tcpClient.Connect("127.0.0.1", 5000);
            using (var networkStream = tcpClient.GetStream())
            {
                task = Write(networkStream,byteArray,0);
                Task continuation = task.ContinueWith(ant => Read(ant, networkStream), TaskContinuationOptions.NotOnFaulted | TaskContinuationOptions.AttachedToParent);

                return continuation;
            }
        }
    }

        private static Task Write(NetworkStream stream, byte[] buffer, int offset)
    {
        return Task.Factory.FromAsync(stream.BeginWrite, stream.EndWrite, buffer, offset, buffer.Length, null);
    }

    private static Task Read(Task write, NetworkStream stream)
    {

        byte[] data = new byte[50];
        return Task<int>.Factory.FromAsync(stream.BeginRead, stream.EndRead, data, 0, data.Length, null);

    }

在Task.WaitAll(tasks)行上的MeasureAsyncTPL中拾取异常。我该如何解决此异常？

第二个问题 - 我的Read方法中的FromAsync是否保证从服务器返回整个消息？或者我需要多次调用它，同时跟踪服务器发送的字节数组的大小？

Answer 1

在写入和读取操作开始或有时间工作之前，您正在处置networkStream和tcpClient。

使用.NET 4.0，你需要做一些像这样复杂的事情（这是开始的事情，它需要更多的工作）：

var byteArray = MessageToByteArray(message, Encoding.UTF8);

var tcpClient = new TcpClient();

NetworkStream networkStream = null;

try
{
    tcpClient.Connect("127.0.0.1", 5000);

    networkStream = tcpClient.GetStream();
}
catch
{
    ((IDisposable)tcpClient).Dispose();
    throw;
}

byte[] read_buffer = new byte[50];

Action dispose_action = () =>
{
    ((IDisposable)tcpClient).Dispose();
    networkStream.Dispose();
};

var write_task = networkStream.WriteAsync(byteArray, 0, byteArray.Length);

write_task
    .ContinueWith(wt =>
    {
        var read_task = networkStream.ReadAsync(read_buffer, 0, read_buffer.Length);


        read_task.ContinueWith(rt =>
        {
            //See if rt task is successful and if so, process read data here

            dispose_action();
        });

    },
    TaskContinuationOptions.OnlyOnRanToCompletion);

write_task.ContinueWith(wt => dispose_action, TaskContinuationOptions.NotOnRanToCompletion);

上面代码的主要思想是，在完成读/写操作之前，不要丢弃TCP客户端和网络流对象。

想象一下，如果你想在某种循环中多次阅读，这段代码会变得多么复杂。

使用.NET 4.5，您可以使用async和await执行某些操作（更简单），如下所示：

static async Task SendMessageToServerAsync(string message)
{
    var byteArray = MessageToByteArray(message, Encoding.UTF8);
    using (var tcpClient = new TcpClient())
    {
        tcpClient.Connect("127.0.0.1", 5000);
        using (var networkStream = tcpClient.GetStream())
        {
            await networkStream.WriteAsync(byteArray, 0, byteArray.Length);

            byte[] read_buffer = new byte[50];

            int read = await networkStream.ReadAsync(read_buffer, 0, read_buffer.Length);

            // do something with the read_buffer
        }
    }
}

TPL FromAsync Task不断被取消

1 个答案: