1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
|
// ==++==
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ==--==
// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
//
// TaskExtensions.cs
//
// <OWNER>Microsoft</OWNER>
//
// Extensions to Task/Task<TResult> classes
//
// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using System.Diagnostics.Contracts;
#if !SILVERLIGHT || FEATURE_NETCORE // Desktop and CoreSys but not CoreCLR
using System.Runtime.ExceptionServices;
#endif
namespace System.Threading.Tasks
{
/// <summary>
/// Provides a set of static (Shared in Visual Basic) methods for working with specific kinds of
/// <see cref="System.Threading.Tasks.Task"/> instances.
/// </summary>
public static class TaskExtensions
{
/// <summary>
/// Creates a proxy <see cref="System.Threading.Tasks.Task">Task</see> that represents the
/// asynchronous operation of a Task{Task}.
/// </summary>
/// <remarks>
/// It is often useful to be able to return a Task from a <see cref="System.Threading.Tasks.Task{TResult}">
/// Task{TResult}</see>, where the inner Task represents work done as part of the outer Task{TResult}. However,
/// doing so results in a Task{Task}, which, if not dealt with carefully, could produce unexpected behavior. Unwrap
/// solves this problem by creating a proxy Task that represents the entire asynchronous operation of such a Task{Task}.
/// </remarks>
/// <param name="task">The Task{Task} to unwrap.</param>
/// <exception cref="T:System.ArgumentNullException">The exception that is thrown if the
/// <paramref name="task"/> argument is null.</exception>
/// <returns>A Task that represents the asynchronous operation of the provided Task{Task}.</returns>
public static Task Unwrap(this Task<Task> task)
{
if (task == null) throw new ArgumentNullException("task");
#if SILVERLIGHT && !FEATURE_NETCORE // CoreCLR only
bool result;
// tcs.Task serves as a proxy for task.Result.
// AttachedToParent is the only legal option for TCS-style task.
var tcs = new TaskCompletionSource<Task>(task.CreationOptions & TaskCreationOptions.AttachedToParent);
// Set up some actions to take when task has completed.
task.ContinueWith(delegate
{
switch (task.Status)
{
// If task did not run to completion, then record the cancellation/fault information
// to tcs.Task.
case TaskStatus.Canceled:
case TaskStatus.Faulted:
result = tcs.TrySetFromTask(task);
Contract.Assert(result, "Unwrap(Task<Task>): Expected TrySetFromTask #1 to succeed");
break;
case TaskStatus.RanToCompletion:
// task.Result == null ==> proxy should be canceled.
if (task.Result == null) tcs.TrySetCanceled();
// When task.Result completes, take some action to set the completion state of tcs.Task.
else
{
task.Result.ContinueWith(_ =>
{
// Copy completion/cancellation/exception info from task.Result to tcs.Task.
result = tcs.TrySetFromTask(task.Result);
Contract.Assert(result, "Unwrap(Task<Task>): Expected TrySetFromTask #2 to succeed");
}, TaskContinuationOptions.ExecuteSynchronously).ContinueWith(antecedent =>
{
// Clean up if ContinueWith() operation fails due to TSE
tcs.TrySetException(antecedent.Exception);
}, TaskContinuationOptions.OnlyOnFaulted);
}
break;
}
}, TaskContinuationOptions.ExecuteSynchronously).ContinueWith(antecedent =>
{
// Clean up if ContinueWith() operation fails due to TSE
tcs.TrySetException(antecedent.Exception);
}, TaskContinuationOptions.OnlyOnFaulted);
// Return this immediately as a proxy. When task.Result completes, or task is faulted/canceled,
// the completion information will be transfered to tcs.Task.
return tcs.Task;
#else // Desktop or CoreSys
// Creates a proxy Task and hooks up the logic to have it represent the task.Result
Task promise = Task.CreateUnwrapPromise<VoidResult>(task, lookForOce : false);
// Return the proxy immediately
return promise;
#endif
}
/// <summary>
/// Creates a proxy <see cref="System.Threading.Tasks.Task{TResult}">Task{TResult}</see> that represents the
/// asynchronous operation of a Task{Task{TResult}}.
/// </summary>
/// <remarks>
/// It is often useful to be able to return a Task{TResult} from a Task{TResult}, where the inner Task{TResult}
/// represents work done as part of the outer Task{TResult}. However, doing so results in a Task{Task{TResult}},
/// which, if not dealt with carefully, could produce unexpected behavior. Unwrap solves this problem by
/// creating a proxy Task{TResult} that represents the entire asynchronous operation of such a Task{Task{TResult}}.
/// </remarks>
/// <param name="task">The Task{Task{TResult}} to unwrap.</param>
/// <exception cref="T:System.ArgumentNullException">The exception that is thrown if the
/// <paramref name="task"/> argument is null.</exception>
/// <returns>A Task{TResult} that represents the asynchronous operation of the provided Task{Task{TResult}}.</returns>
public static Task<TResult> Unwrap<TResult>(this Task<Task<TResult>> task)
{
if (task == null) throw new ArgumentNullException("task");
#if SILVERLIGHT && !FEATURE_NETCORE // CoreCLR only
bool result;
// tcs.Task serves as a proxy for task.Result.
// AttachedToParent is the only legal option for TCS-style task.
var tcs = new TaskCompletionSource<TResult>(task.CreationOptions & TaskCreationOptions.AttachedToParent);
// Set up some actions to take when task has completed.
task.ContinueWith(delegate
{
switch (task.Status)
{
// If task did not run to completion, then record the cancellation/fault information
// to tcs.Task.
case TaskStatus.Canceled:
case TaskStatus.Faulted:
result = tcs.TrySetFromTask(task);
Contract.Assert(result, "Unwrap(Task<Task<T>>): Expected TrySetFromTask #1 to succeed");
break;
case TaskStatus.RanToCompletion:
// task.Result == null ==> proxy should be canceled.
if (task.Result == null) tcs.TrySetCanceled();
// When task.Result completes, take some action to set the completion state of tcs.Task.
else
{
task.Result.ContinueWith(_ =>
{
// Copy completion/cancellation/exception info from task.Result to tcs.Task.
result = tcs.TrySetFromTask(task.Result);
Contract.Assert(result, "Unwrap(Task<Task<T>>): Expected TrySetFromTask #2 to succeed");
},
TaskContinuationOptions.ExecuteSynchronously).ContinueWith(antecedent =>
{
// Clean up if ContinueWith() operation fails due to TSE
tcs.TrySetException(antecedent.Exception);
}, TaskContinuationOptions.OnlyOnFaulted);
}
break;
}
}, TaskContinuationOptions.ExecuteSynchronously).ContinueWith(antecedent =>
{
// Clean up if ContinueWith() operation fails due to TSE
tcs.TrySetException(antecedent.Exception);
}, TaskContinuationOptions.OnlyOnFaulted); ;
// Return this immediately as a proxy. When task.Result completes, or task is faulted/canceled,
// the completion information will be transfered to tcs.Task.
return tcs.Task;
#else // Desktop or CoreSys
// Creates a proxy Task<TResult> and hooks up the logic to have it represent the task.Result
Task<TResult> promise = Task.CreateUnwrapPromise<TResult>(task, lookForOce : false);
// Return the proxy immediately
return promise;
#endif
}
#if SILVERLIGHT && !FEATURE_NETCORE // CoreCLR only
// Transfer the completion status from "source" to "me".
private static bool TrySetFromTask<TResult>(this TaskCompletionSource<TResult> me, Task source)
{
Contract.Assert(source.IsCompleted, "TrySetFromTask: Expected source to have completed.");
bool rval = false;
switch(source.Status)
{
case TaskStatus.Canceled:
rval = me.TrySetCanceled();
break;
case TaskStatus.Faulted:
rval = me.TrySetException(source.Exception.InnerExceptions);
break;
case TaskStatus.RanToCompletion:
if(source is Task<TResult>)
rval = me.TrySetResult( ((Task<TResult>)source).Result);
else
rval = me.TrySetResult(default(TResult));
break;
}
return rval;
}
#else // Desktop or CoreSys
// Used as a placeholder TResult to indicate that a Task<TResult> has a void TResult
private struct VoidResult { }
#endif
}
}
|
