什么时候应该使用 TaskCompletionSource<T>？

Question

AFAIK，它所知道的是，在某个时候，它的 SetResult 或 SetException 方法被调用以完成通过其 Task 属性公开的 Task<T>。

换句话说，它充当Task<TResult> 及其完成的生产者。

我看到here的例子：

如果我需要一种异步执行Func<T> 并拥有Task<T> 的方法 表示该操作。

public static Task<T> RunAsync<T>(Func<T> function) 
{ 
    if (function == null) throw new ArgumentNullException(“function”); 
    var tcs = new TaskCompletionSource<T>(); 
    ThreadPool.QueueUserWorkItem(_ => 
    { 
        try 
        {  
            T result = function(); 
            tcs.SetResult(result);  
        } 
        catch(Exception exc) { tcs.SetException(exc); } 
    }); 
    return tcs.Task; 
}

如果我没有Task.Factory.StartNew，可以使用哪个 - 但我确实有Task.Factory.StartNew。

问题：

有人可以举例说明一个与TaskCompletionSource直接相关的场景吗？ 而不是我没有Task.Factory.StartNew的假设情况？

Answer 1

我主要在只有基于事件的 API 可用时使用它 (for example Windows Phone 8 sockets)：

public Task<Args> SomeApiWrapper()
{
    TaskCompletionSource<Args> tcs = new TaskCompletionSource<Args>(); 

    var obj = new SomeApi();

    // will get raised, when the work is done
    obj.Done += (args) => 
    {
        // this will notify the caller 
        // of the SomeApiWrapper that 
        // the task just completed
        tcs.SetResult(args);
    }

    // start the work
    obj.Do();

    return tcs.Task;
}

因此与 C#5 async 关键字一起使用时特别有用。

Answer 2

根据我的经验，TaskCompletionSource 非常适合将旧的异步模式包装到现代的 async/await 模式中。

我能想到的最有益的例子是使用Socket 时。它具有旧的 APM 和 EAP 模式，但没有 TcpListener 和 TcpClient 拥有的 awaitable Task 方法。

我个人对NetworkStream 类有几个问题，我更喜欢原始的Socket。因为我也喜欢async/await 模式，所以我创建了一个扩展类SocketExtender，它为Socket 创建了几个扩展方法。

所有这些方法都使用TaskCompletionSource<T> 来包装异步调用，如下所示：

    public static Task<Socket> AcceptAsync(this Socket socket)
    {
        if (socket == null)
            throw new ArgumentNullException("socket");

        var tcs = new TaskCompletionSource<Socket>();

        socket.BeginAccept(asyncResult =>
        {
            try
            {
                var s = asyncResult.AsyncState as Socket;
                var client = s.EndAccept(asyncResult);

                tcs.SetResult(client);
            }
            catch (Exception ex)
            {
                tcs.SetException(ex);
            }

        }, socket);

        return tcs.Task;
    }

我将socket 传递给BeginAccept 方法，这样我就可以从编译器中获得轻微的性能提升，而不必提升本地参数。

然后是这一切的美丽：

 var listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
 listener.Bind(new IPEndPoint(IPAddress.Loopback, 2610));
 listener.Listen(10);

 var client = await listener.AcceptAsync();

Answer 3

对我来说，使用TaskCompletionSource 的一个经典场景是我的方法可能不一定必须执行耗时的操作。它允许我们做的是选择我们想要使用新线程的特定情况。

当您使用缓存时就是一个很好的例子。您可以使用GetResourceAsync 方法，该方法在缓存中查找请求的资源，如果找到资源，则立即返回（不使用新线程，使用TaskCompletionSource）。只有在找不到资源的情况下，我们才会使用新线程并使用Task.Run() 检索它。

可以在此处查看代码示例：How to conditionally run a code asynchonously using tasks

Answer 4

在this blog post 中，Levi Botelho 描述了如何使用TaskCompletionSource 为 Process 编写异步包装器，以便您可以启动它并等待其终止。

public static Task RunProcessAsync(string processPath)
{
    var tcs = new TaskCompletionSource<object>();
    var process = new Process
    {
        EnableRaisingEvents = true,
        StartInfo = new ProcessStartInfo(processPath)
        {
            RedirectStandardError = true,
            UseShellExecute = false
        }
    };
    process.Exited += (sender, args) =>
    {
        if (process.ExitCode != 0)
        {
            var errorMessage = process.StandardError.ReadToEnd();
            tcs.SetException(new InvalidOperationException("The process did not exit correctly. " +
                "The corresponding error message was: " + errorMessage));
        }
        else
        {
            tcs.SetResult(null);
        }
        process.Dispose();
    };
    process.Start();
    return tcs.Task;
}

及其用法

await RunProcessAsync("myexecutable.exe");

Answer 5

似乎没有人提到，但我想单元测试也可以被认为是现实生活。

我发现TaskCompletionSource 在使用异步方法模拟依赖项时很有用。

在实际被测程序中：

public interface IEntityFacade
{
  Task<Entity> GetByIdAsync(string id);
}

在单元测试中：

// set up mock dependency (here with NSubstitute)

TaskCompletionSource<Entity> queryTaskDriver = new TaskCompletionSource<Entity>();

IEntityFacade entityFacade = Substitute.For<IEntityFacade>();

entityFacade.GetByIdAsync(Arg.Any<string>()).Returns(queryTaskDriver.Task);

// later on, in the "Act" phase

private void When_Task_Completes_Successfully()
{
  queryTaskDriver.SetResult(someExpectedEntity);
  // ...
}

private void When_Task_Gives_Error()
{
  queryTaskDriver.SetException(someExpectedException);
  // ...
}

毕竟，TaskCompletionSource 的这种用法似乎是“不执行代码的任务对象”的另一种情况。

Answer 6

TaskCompletionSource 用于创建不执行代码的Task 对象。 在现实世界的场景中，TaskCompletionSource 是 I/O 绑定操作的理想选择。这样，您可以获得任务的所有好处（例如返回值、延续等），而不会在操作期间阻塞线程。如果您的“函数”是 I/O 绑定操作，则不建议使用新的 Task 阻塞线程。相反，使用 TaskCompletionSource，您可以创建一个从属任务来指示您的 I/O 绑定操作何时完成或出现故障。

Answer 7

post from the "Parallel Programming with .NET" blog 中有一个真实世界的例子，有一个不错的解释。您确实应该阅读它，但无论如何这里是一个摘要。

博客文章展示了以下两种实现：

“一种用于创建“延迟”任务的工厂方法，那些不会 实际上会被安排，直到发生一些用户提供的超时。”

显示的第一个实现基于Task<>，有两个主要缺陷。第二个实现帖子继续使用TaskCompletionSource<> 来缓解这些问题。

这是第二个实现：

public static Task StartNewDelayed(int millisecondsDelay, Action action)
{
    // Validate arguments
    if (millisecondsDelay < 0)
        throw new ArgumentOutOfRangeException("millisecondsDelay");
    if (action == null) throw new ArgumentNullException("action");

    // Create a trigger used to start the task
    var tcs = new TaskCompletionSource<object>();

    // Start a timer that will trigger it
    var timer = new Timer(
        _ => tcs.SetResult(null), null, millisecondsDelay, Timeout.Infinite);

    // Create and return a task that will be scheduled when the trigger fires.
    return tcs.Task.ContinueWith(_ =>
    {
        timer.Dispose();
        action();
    });
}

Answer 8

这可能过于简单了，但 TaskCompletion 源允许人们等待事件。由于 tcs.SetResult 仅在事件发生时设置，调用者可以等待任务。

观看此视频以获得更多见解：

http://channel9.msdn.com/Series/Three-Essential-Tips-for-Async/Lucian03-TipsForAsyncThreadsAndDatabinding

Answer 9

我使用TaskCompletionSource 的真实场景是在实现下载队列时。在我的情况下，如果用户开始 100 次下载，我不想一次将它们全部关闭，因此我没有返回一个分层任务，而是返回一个附加到 TaskCompletionSource 的任务。一旦下载完成，队列中的线程就会完成任务。

这里的关键概念是，当客户要求从实际开始时开始执行任务时，我正在解耦。在这种情况下，因为我不希望客户端必须处理资源管理。

请注意，只要您使用 C# 5 编译器（VS 2012+），您就可以在 .net 4 中使用 async/await，请参阅 here 了解更多详细信息。

Answer 10

我使用TaskCompletionSource 运行一个任务，直到它被取消。在这种情况下，它是一个 ServiceBus 订阅者，我通常希望在应用程序运行期间一直运行它。

public async Task RunUntilCancellation(
    CancellationToken cancellationToken,
    Func<Task> onCancel)
{
    var doneReceiving = new TaskCompletionSource<bool>();

    cancellationToken.Register(
        async () =>
        {
            await onCancel();
            doneReceiving.SetResult(true); // Signal to quit message listener
        });

    await doneReceiving.Task.ConfigureAwait(false); // Listen until quit signal is received.
}