I want to create a completed Task
(not Task<T>
). Is there something built into .NET to do this?
A related question: Create a completed Task<T>
I want to create a completed Task
(not Task<T>
). Is there something built into .NET to do this?
A related question: Create a completed Task<T>
The newest version of .Net (v4.6) is adding just that, a built-in Task.CompletedTask:
Task completedTask = Task.CompletedTask;
That property is implemented as a no-lock singleton so you would almost always be using the same completed task.
Task<T>
is implicitly convertable to Task
, so just get a completed Task<T>
(with any T
and any value) and use that. You can use something like this to hide the fact that an actual result is there, somewhere.
private static Task completedTask = Task.FromResult(false);
public static Task CompletedTask()
{
return completedTask;
}
Note that since we aren't exposing the result, and the task is always completed, we can cache a single task and reuse it.
If you're using .NET 4.0 and don't have FromResult
then you can create your own using TaskCompletionSource
:
public static Task<T> FromResult<T>(T value)
{
var tcs = new TaskCompletionSource<T>();
tcs.SetResult(value);
return tcs.Task;
}
My preferred method for doing this is to call Task.WhenAll()
with no arguments. The MSDN documentation states that "If the supplied array/enumerable contains no tasks, the returned task will immediately transition to a RanToCompletion state before it's returned to the caller.". That sounds like what you want.
Update: I found the source over at Microsoft's Reference Source; there you can see that Task.WhenAll contains the following:
return (tasks.Length == 0) ? // take shortcut if there are no tasks upon which to wait
Task.CompletedTask :
new WhenAllPromise(tasks);
So Task.CompletedTask is indeed internal, but it is exposed by calling WhenAll() with no arguments.
I would use Task.Delay(0)
. Internally, it returns a cached instance of a completed Task<T>
. This is exactly what the current answer suggest doing anyway, only now you don't have to cache an instance yourself, nor do you have any inelegant garbage values in your code.
You might be thinking you can use Task.Yield()
instead, but it turns out the result of Task.Yield()
is not a subtype of Task
, whereas the result of Task.Delay(0)
is. That's one of the subtle differences between the two.
You can use Task.FromResult (in .NET 4.5) to return a completed Task<T>
.
If you need a non-generic Task
, you can always use Task.FromResult(0)
or similar, since Task<T>
is a subclass of Task
.
It seems like the answer I'm getting from everyone is that using a garbage value like this is the correct way. That there isn't a way to do this without the garbage value is disappointing -- oh well.
What problems do you think this has? If you cache a singleTask
then your entire program takes up one extra bit of memory. That's nothing. Also, one could create a completed task without doing that, it just wouldn't be any better. – ServyValueTask
for completed tasks (i.e. for values you already have so that code is essentially synchronous), which will save you an allocation. – nawfal