blocks|key|193238|text|我主要在只有基于事件的API可用时使用它(for+example+Windows+Phone+8+sockets)：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|193239|public+Task<Args>+SomeApiWrapper()
{
++++TaskCompletionSource<Args>+tcs+=+new+TaskCompletionSource<Args>();+

++++var+obj+=+new+SomeApi();

++++//+will+get+raised,+when+the+work+is+done
++++obj.Done+%2B=+(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;
}|code-block|syntax|javascript|193240|因此，当它与C#5+async关键字一起使用时特别有用。|style|CODE|193241|entityMap|0|LINK|mutability|MUTABLE|url|http://code.msdn.microsoft.com/Windows-Phone-8-Networking-835239c1/sourcecode?fileId=70769&pathId=221052408^0|L|Z|0|0|0|A|5|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@$A|10|B|11|K|L]]|9|@]|C|$]]|$1|M|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

I mostly use it when only an event based API is available (<a href="http://code.msdn.microsoft.com/Windows-Phone-8-Networking-835239c1/sourcecode?fileId=70769&amp;pathId=221052408" rel="noreferrer">for example Windows Phone 8 sockets</a>):

<pre><code>public Task&lt;Args&gt; SomeApiWrapper()
{
 TaskCompletionSource&lt;Args&gt; tcs = new TaskCompletionSource&lt;Args&gt;(); 

 var obj = new SomeApi();

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

 // start the work
 obj.Do();

 return tcs.Task;
}
</code></pre>

So it's especially useful when used together with the C#5 <code>async</code> keyword.

blocks|key|195359|text|对我来说，使用TaskCompletionSource的一个经典场景是，我的方法可能不一定要执行耗时的操作。它允许我们选择我们想要使用新线程的特定情况。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|195360|一个很好的例子是当你使用缓存的时候。您可以使用GetResourceAsync方法，该方法在缓存中查找请求的资源，如果找到资源，则立即返回(不使用新线程，使用TaskCompletionSource)。只有在没有找到资源的情况下，我们才会使用一个新线程，并使用Task.Run()检索它。|195361|代码示例可以在这里看到：How+to+conditionally+run+a+code+asynchonously+using+tasks|195362|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/q/8575889/389966^0|7|K|0|N|G|27|K|3M|A|0|C|1L|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|11|8|@]|D|@$9|12|A|13|1|14]]|E|$]]|$1|J|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]]]

To me, a classic scenario for using <code>TaskCompletionSource</code> is when it's possible that my method won't necessarily have to do a time consuming operation. What it allows us to do is to choose the specific cases where we'd like to use a new thread.

A good example for this is when you use a cache. You can have a <code>GetResourceAsync</code> method, which looks in the cache for the requested resource and returns at once (without using a new thread, by using <code>TaskCompletionSource</code>) if the resource was found. Only if the resource wasn't found, we'd like to use a new thread and retrieve it using <code>Task.Run()</code>.

A code example can be seen here: <a href="https://stackoverflow.com/q/8575889/389966">How to conditionally run a code asynchonously using tasks</a>

blocks|key|197501|text|我在现实世界中使用TaskCompletionSource的场景是在实现下载队列时。在我的例子中，如果用户开始了100次下载，我不想一次完成所有的下载，所以我没有返回一个分层的任务，而是返回了一个附加到TaskCompletionSource的任务。一旦下载完成，正在工作的线程队列就会完成任务。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|197502|这里的关键概念是，当客户端请求启动一个任务时，我将其与实际启动的任务解耦。在这种情况下，因为我不希望客户端必须处理资源管理。|197503|请注意，只要您使用的是C#+5编译器(VS+2012%2B)，就可以在.net+4中使用async/await。有关更多详细信息，请参阅here。|197504|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/9110472/using-async-await-on-net-4^0|9|K|2T|K|0|0|1U|4|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|X|8|@]|D|@$9|Y|A|Z|1|10]]|E|$]]|$1|J|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]]]

I real world scenario where I have used <code>TaskCompletionSource</code> is when implementing a download queue. In my case if the user starts 100 downloads I don't want to fire them all off at once and so instead of returning a strated task I return a task attached to <code>TaskCompletionSource</code>. Once the download gets completed the thread that is working the queue completes the task. 

The key concept here is that I am decoupling when a client asks for a task to be started from when it actually gets started. In this case because I don't want the client to have to deal with resource management.

note that you can use async/await in .net 4 as long as you are using a C# 5 compiler (VS 2012+) see <a href="https://stackoverflow.com/questions/9110472/using-async-await-on-net-4">here</a> for more details.

blocks|key|195402|text|根据我的经验，TaskCompletionSource非常适合将旧的异步模式包装成现代的async/await模式。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|195403|我能想到的最有益的例子是在使用Socket时。它具有旧的APM和EAP模式，但没有TcpListener和TcpClient所具有的awaitable+Task方法。|195404|我个人对NetworkStream类有几个问题，我更喜欢原始的Socket。因为我也喜欢async/await模式，所以我创建了一个扩展类SocketExtender，它为Socket创建了几个扩展方法。|195405|所有这些方法都使用TaskCompletionSource<T>来包装异步调用，如下所示：|195406|++++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;
++++}|code-block|syntax|javascript|195407|我将socket传递给BeginAccept方法，这样我就可以从编译器中获得轻微的性能提升，而不必提升本地参数。|195408|这一切的美妙之处在于：|195409|+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();|195410|entityMap^0|7|K|18|B|0|F|6|15|B|1H|9|1U|E|0|4|D|V|6|18|B|1X|E|2E|6|0|9|N|0|0|2|6|B|B|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|1N|8|@$9|1O|A|1P|B|C]]|D|@]|E|$]]|$1|L|3|M|5|N|7|1Q|8|@]|D|@]|E|$O|P]]|$1|Q|3|R|5|6|7|1R|8|@$9|1S|A|1T|B|C]|$9|1U|A|1V|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1W|8|@]|D|@]|E|$]]|$1|U|3|V|5|N|7|1X|8|@]|D|@]|E|$O|P]]|$1|W|3|-4|5|6|7|1Y|8|@]|D|@]|E|$]]]|X|$]]

In my experiences, <code>TaskCompletionSource</code> is great for wrapping old asynchronous patterns to the modern <code>async/await</code> pattern.

The most beneficial example I can think of is when working with <code>Socket</code>. It has the old APM and EAP patterns, but not the <code>awaitable Task</code> methods that <code>TcpListener</code> and <code>TcpClient</code> have. 

I personally have several issues with the <code>NetworkStream</code> class and prefer the raw <code>Socket</code>. Being that I also love the <code>async/await</code> pattern, I made an extension class <code>SocketExtender</code> which creates several extension methods for <code>Socket</code>.

All of these methods make use of <code>TaskCompletionSource&lt;T&gt;</code> to wrap the asynchronous calls like so:

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

 var tcs = new TaskCompletionSource&lt;Socket&gt;();

 socket.BeginAccept(asyncResult =&gt;
 {
 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;
 }
</code></pre>

I pass the <code>socket</code> into the <code>BeginAccept</code> methods so that I get a slight performance boost out of the compiler not having to hoist the local parameter.

Then the beauty of it all:

<pre><code> 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();
</code></pre>

blocks|key|2821153|text|TaskCompletionSource用于创建不执行代码的任务对象。在实际场景中，TaskCompletionSource是I/O受限操作的理想选择。这样，您可以获得任务的所有好处(例如返回值、延续等)，而不会在操作期间阻塞线程。如果您的“函数”是I/O绑定操作，则不建议使用新任务阻塞线程。相反，使用TaskCompletionSource，您可以创建一个从任务，以仅指示I/O绑定操作何时完成或出现故障。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2821154|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

TaskCompletionSource is used to create Task objects that don't execute code.
In real world scenarios, TaskCompletionSource is ideal for I/O bound operations. This way, you get all the benefits of tasks (e.g. return values, continuations, etc) without blocking a thread for the duration of the operation. If your "function" is an I/O bound operation, it isn't recommended to block a thread using a new Task. Instead, using TaskCompletionSource, you can create a slave task to just indicate when your I/O bound operation finishes or faults.

blocks|key|195418|text|在这个post+from+the+"Parallel+Programming+with+.NET"+blog中，有一个真实的例子给出了一个很好的解释。你真的应该读一读，但不管怎样，这是一个总结。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|195419|这篇博文展示了两个实现：|195420|195421|“一种工厂方法，用于创建”延迟“任务，这些任务在用户提供的超时发生之前不会被实际调度。”|blockquote|195422|195423|195424|显示的第一个实现基于Task<>，有两个主要缺陷。第二个实现帖子继续使用TaskCompletionSource<>来缓解这些问题。|style|CODE|195425|下面是第二个实现：|195426|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();
++++});
}|code-block|syntax|javascript|195427|entityMap|0|LINK|mutability|MUTABLE|url|http://blogs.msdn.com/b/pfxteam/archive/2009/06/03/9691796.aspx^0|3|1F|0|0|0|0|0|0|0|A|6|10|M|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]]|C|$]]|$1|D|3|E|5|6|7|18|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|19|8|@]|9|@]|C|$]]|$1|G|3|H|5|I|7|1A|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|1B|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|1C|8|@]|9|@]|C|$]]|$1|L|3|M|5|6|7|1D|8|@$A|1E|B|1F|N|O]|$A|1G|B|1H|N|O]]|9|@]|C|$]]|$1|P|3|Q|5|6|7|1I|8|@]|9|@]|C|$]]|$1|R|3|S|5|T|7|1J|8|@]|9|@]|C|$U|V]]|$1|W|3|-4|5|6|7|1K|8|@]|9|@]|C|$]]]|X|$Y|$5|Z|10|11|C|$12|13]]]]

There's a real world example with a decent explanation in this <a href="http://blogs.msdn.com/b/pfxteam/archive/2009/06/03/9691796.aspx" rel="noreferrer">post from the "Parallel Programming with .NET" blog</a>. You really should read it, but here's a summary anyway.

The blog post shows two implementations for:

<blockquote>
 "a factory method for creating “delayed” tasks, ones that won’t
 actually be scheduled until some user-supplied timeout has occurred."
</blockquote>

The first implementation shown is based on <code>Task&lt;&gt;</code> and has two major flaws. The second implementation post goes on to mitigate these by using <code>TaskCompletionSource&lt;&gt;</code>.

Here's that second implementation:

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

 // Create a trigger used to start the task
 var tcs = new TaskCompletionSource&lt;object&gt;();

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

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

blocks|key|3033639|text|在this+blog+post中，Levi+Botelho描述了如何使用TaskCompletionSource为进程编写异步包装器，以便您可以启动它并等待其终止。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3033640|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+%2B=+(sender,+args)+=>
++++{
++++++++if+(process.ExitCode+!=+0)
++++++++{
++++++++++++var+errorMessage+=+process.StandardError.ReadToEnd();
++++++++++++tcs.SetException(new+InvalidOperationException("The+process+did+not+exit+correctly.+"+%2B
++++++++++++++++"The+corresponding+error+message+was:+"+%2B+errorMessage));
++++++++}
++++++++else
++++++++{
++++++++++++tcs.SetResult(null);
++++++++}
++++++++process.Dispose();
++++};
++++process.Start();
++++return+tcs.Task;
}|code-block|syntax|javascript|3033641|及其用法|3033642|await+RunProcessAsync("myexecutable.exe");|3033643|entityMap|0|LINK|mutability|MUTABLE|url|http://www.levibotelho.com/development/async-processes-with-taskcompletionsource^0|10|K|1|E|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

In <a href="http://www.levibotelho.com/development/async-processes-with-taskcompletionsource" rel="noreferrer">this blog post</a>, Levi Botelho describes how to use the <code>TaskCompletionSource</code> to write an asynchronous wrapper for a Process such that you can launch it and await its termination.

<pre><code>public static Task RunProcessAsync(string processPath)
{
 var tcs = new TaskCompletionSource&lt;object&gt;();
 var process = new Process
 {
 EnableRaisingEvents = true,
 StartInfo = new ProcessStartInfo(processPath)
 {
 RedirectStandardError = true,
 UseShellExecute = false
 }
 };
 process.Exited += (sender, args) =&gt;
 {
 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;
}
</code></pre>

and its usage

<pre><code>await RunProcessAsync("myexecutable.exe");
</code></pre>

blocks|key|3033658|text|这可能过于简单化了，但是TaskCompletion源代码允许等待一个事件。由于tcs.SetResult仅在事件发生时设置，因此调用者可以等待任务。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3033659|观看此视频以了解更多见解：|3033660|http://channel9.msdn.com/Series/Three-Essential-Tips-for-Async/Lucian03-TipsForAsyncThreadsAndDatabinding|offset|length|3033661|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|2X|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@$F|R|G|S|1|T]]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|E]]]]

This may be oversimplifying things but the TaskCompletion source allows one to await on an event. Since the tcs.SetResult is only set once the event occurs, the caller can await on the task.

Watch this video for more insights:

<a href="http://channel9.msdn.com/Series/Three-Essential-Tips-for-Async/Lucian03-TipsForAsyncThreadsAndDatabinding" rel="nofollow">http://channel9.msdn.com/Series/Three-Essential-Tips-for-Async/Lucian03-TipsForAsyncThreadsAndDatabinding</a>

blocks|key|195466|text|看起来没有人提到，但我想单元测试也可以被认为是现实生活中的足够。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|195467|我发现TaskCompletionSource在使用异步方法模拟依赖项时非常有用。|offset|length|style|CODE|195468|在实际测试程序中：|195469|public+interface+IEntityFacade
{
++Task<Entity>+GetByIdAsync(string+id);
}|code-block|syntax|javascript|195470|在单元测试中：|195471|//+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);
++//+...
}|195472|毕竟，TaskCompletionSource的这种用法似乎是“不执行代码的任务对象”的另一种情况。|195473|entityMap^0|0|3|K|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@$D|Y|E|Z|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|10|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|11|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|13|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

It looks like no one mentioned, but I guess unit tests too can be considered real life enough.

I find <code>TaskCompletionSource</code> to be useful when mocking a dependency with an async method.

In actual program under test: 

<pre><code>public interface IEntityFacade
{
 Task&lt;Entity&gt; GetByIdAsync(string id);
}
</code></pre>

In unit tests:

<pre><code>// set up mock dependency (here with NSubstitute)

TaskCompletionSource&lt;Entity&gt; queryTaskDriver = new TaskCompletionSource&lt;Entity&gt;();

IEntityFacade entityFacade = Substitute.For&lt;IEntityFacade&gt;();

entityFacade.GetByIdAsync(Arg.Any&lt;string&gt;()).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);
 // ...
}
</code></pre>

After all, this usage of TaskCompletionSource seems another case of "a Task object that does not execute code".

blocks|key|197557|text|我已经使用TaskCompletionSource来运行一个任务，直到它被取消。在本例中，我通常希望在应用程序运行期间一直运行ServiceBus订阅服务器。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|197558|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.
}|code-block|syntax|javascript|197559|entityMap^0|5|K|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

I've used <code>TaskCompletionSource</code> to run a Task until it is cancelled. In this case it's a ServiceBus subscriber that I normally want to run for as long as the application runs.

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

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

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

AFAIK, all it knows is that at some point, its <code>SetResult</code> or <code>SetException</code> method is being called to complete the <code>Task&lt;T&gt;</code> exposed through its <code>Task</code> property.
In other words, it acts as the producer for a <code>Task&lt;TResult&gt;</code> and its completion.
I saw <a href="https://devblogs.microsoft.com/pfxteam/the-nature-of-taskcompletionsourcetresult/" rel="noreferrer">here</a> the example:
<blockquote>
If I need a way to execute a <code>Func&lt;T&gt;</code> asynchronously and have a <code>Task&lt;T&gt;</code>
to represent that operation.
</blockquote>
<pre><code>public static Task&lt;T&gt; RunAsync&lt;T&gt;(Func&lt;T&gt; function) 
{ 
 if (function == null) throw new ArgumentNullException(“function”); 
 var tcs = new TaskCompletionSource&lt;T&gt;(); 
 ThreadPool.QueueUserWorkItem(_ =&gt; 
 { 
 try 
 { 
 T result = function(); 
 tcs.SetResult(result); 
 } 
 catch(Exception exc) { tcs.SetException(exc); } 
 }); 
 return tcs.Task; 
}
</code></pre>
Which could be used if I didn’t have <code>Task.Factory.StartNew</code> -
But I do have <code>Task.Factory.StartNew</code>.
Question:
Can someone please explain by example a scenario related directly to <code>TaskCompletionSource</code>
and not to a hypothetical situation in which I don't have <code>Task.Factory.StartNew</code>?

When should TaskCompletionSource<T> be used?

单元测试

服务器

编译器

它所知道的就是，在某个时刻，它的SetResult或SetException方法被调用，以完成通过其Task属性公开的Task<T>。换句话说，它充当Task<TResult>及其完成的生产者。我在示例中看到了：如果我需要一种异步执行Func<T>的方法，并且需要一个Task<T>来表示该操作，则使用。public s...

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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