Question

我的代码处理与远程主机的TCP连接，ConcurrentQueue用于存储传出消息。它打算在单个线程中运行。连接的生命周期包含在RunAsync中，而单独的对象包含连接的“公共状态”：

class PublicState
{
    internal readonly ConcurrentQueue<Message> OutgoingMessageQueue = new ConcurrentQueue<Message>();
    internal TaskCompletionSource<Object> OutgoingMessageTcs = null;

    internal readonly TaskCompletionSource<Object> ConnectedTcs = new TaskCompletionSource<Object>();

    public void EnqueueMessages(IEnumerable<Message> messages)
    {
        foreach( Message m in messages ) this.OutgoingMessageQueue.Enqueue( m);
        if( this.OutgoingMessageTcs == null ) this.OutgoingMessageTcs = new TaskCompletionSource<Object>();
        this.OutgoingMessageTcs.SetResult( null );
    }
}

static async Task RunAsync(IPEndPoint endPoint, PublicState state)
{
    using( TcpClient tcp = new TcpClient() )
    {
        await tcp.ConnectAsync( endPoint.Address, endPoint.Port ).ConfigureAwait(false);

        Byte[] reusableBuffer = new Byte[ 4096 ];

        using( NetworkStream ns = tcp.GetStream() )
        {
            state.ConnectedTcs.SetResult( null );

            Task<Int32> nsReadTask = null;

            while( tcp.Connected )
            {
                if( !state.writeQueue.IsEmpty )
                {
                    await WriteMessagesAsync( ... ).ConfigureAwait( false );
                }

                if( ns.DataAvailable )
                {
                    await ReadMessagesAsync( ... ).ConfigureAwait( false );
                }

                // Wait for new data to arrive from remote host or for new messages to send:
                if( state.OutgoingMessageTcs == null ) state.OutgoingMessageTcs = new TaskCompletionSource<Object>();
                if( nsReadTask == null ) nsReadTask = ns.ReadAsync( reusableBuffer, 0, 0 ).ConfigureAwait( false );

                Task c = await Task.WhenAny( state.OutgoingMessageTcs,  nsReadTask ).ConfigureAwait( false );
                if( c == state.OutgoingMessageTcs.Task ) state.OutgoingMessageTcs = null;
                else if( c == nsReadTask ) nsReadTask = null;
            }
        }
    }
}

像这样使用：

public async Task Main(String[] args)
{
    PublicState state = new PublicState();
    Task clientTask = Client.RunAsync( new IPEndPoint(args[0]), state );

    await state.ConnectedTcs.Task; // awaits until TCP connection is established

    state.EnqueueMessage( new Message("foo") );
    state.EnqueueMessage( new Message("bar") );
    state.EnqueueMessage( new Message("baz") );

    await clientTask; // awaits until the TCP connection is closed
}

这段代码有效，但我不喜欢它：感觉我正在使用TaskCompletionSource来表示实际的任务或某种背景操作，而我实际上正在使用{{ 1}}作为一种廉价的TaskCompletionSource。我没有使用EventWaitHandle，因为它是EventWaitHandle（我不想冒泄漏本机资源的风险）并且它缺少IDisposable或WaitAsync方法。我可以使用WaitOneAsync（这是等待的，但是包装SemaphoreSlim）但我的代码并不能真正代表信号量的良好用途。

我对EventWaitHandle的使用是否可以接受，或者当某个项目添加到TaskCompletionSource<T>时，是否有更好的方式在RunAsync中“取消等待”执行？

我认为它“错误”的另一个原因是OutgoingMessageQueue只能使用一次，然后需要更换。我渴望避免无关的分配。

Answer 1

如果我理解正确 - TPL BufferBlock可能就是您所需要的。当前Enqueue的模拟值为Post，您可以通过ReceiveAsync扩展方法接收下一个值。

因此，使用BufferBlock，您的代码就会变成这样：

class PublicState {
    internal readonly BufferBlock<Message> OutgoingMessageQueue = new BufferBlock<Message>();
    internal readonly TaskCompletionSource<Object> ConnectedTcs = new TaskCompletionSource<Object>();

    public void EnqueueMessage(Message message) {
        this.OutgoingMessageQueue.Post(message);
    }
}

static async Task RunAsync(IPEndPoint endPoint, PublicState state) {
    using (TcpClient tcp = new TcpClient()) {
        await tcp.ConnectAsync(endPoint.Address, endPoint.Port).ConfigureAwait(false);

        Byte[] reusableBuffer = new Byte[4096];

        using (NetworkStream ns = tcp.GetStream()) {
            state.ConnectedTcs.SetResult(null);

            Task<Int32> nsReadTask = null;
            Task<Message> newMessageTask = null;
            while (tcp.Connected) {
                // Wait for new data to arrive from remote host or for new messages to send:
                if (nsReadTask == null)
                    nsReadTask = ns.ReadAsync(reusableBuffer, 0, 0);
                if (newMessageTask == null)
                    newMessageTask = state.OutgoingMessageQueue.ReceiveAsync();
                var completed = await Task.WhenAny(nsReadTask, newMessageTask).ConfigureAwait(false);
                if (completed == newMessageTask) {
                    var result = await newMessageTask;
                    // do stuff
                    newMessageTask = null;
                }
                else {
                    var bytesRead = await nsReadTask;
                    nsReadTask = null;
                }
            }
        }
    }
}

作为奖励，这个版本（我认为）是线程安全的，而你当前的版本不是，因为你正在使用来自潜在多线程OutgoingMessageTcs的非线程安全的东西（{{1}的线程1}}和RunAsync来电者的线程。）

如果由于某种原因您不喜欢EnqueueMessages - 您可以完全以同样的方式使用BufferBlock nuget包中的AsyncCollection。初始化变为：

Nito.AsyncEx

获取：

internal readonly AsyncCollection<Message> OutgoingMessageQueue = new AsyncCollection<Message>(new ConcurrentQueue<Message>());

Answer 2

为了备份其他人提到的内容，它看起来像Microsoft的文档提到，甚至鼓励开发一个写在Task对象here之上的Semaphore类：

您还可以构建一个不依赖于等待句柄的异步信号量，而是完全使用任务。为此，您可以使用诸如使用基于任务的异步模式中讨论的技术来在任务之上构建数据结构。

这确实让我想知道为什么这样的预先包装的类不存在，但它确实表明这很好。

使用TaskCompletionSource作为WaitHandle替代品是否可以接受？

2 个答案: