System.Threading.Tasks.Extensions
Provides an awaitable type that enables configured awaits on a .
The type of the result produced.
The wrapped .
true to attempt to marshal the continuation back to the original context captured; otherwise, false.
Initializes the awaitable.
The wrapped .
true to attempt to marshal the continuation back to the original synchronization context captured; otherwise, false.
Returns an awaiter for this instance.
Provides an awaiter for a .
The value being awaited.
The value to pass to ConfigureAwait.
Initializes the awaiter.
The value to be awaited.
The value to pass to ConfigureAwait.
Gets whether the has completed.
Gets the result of the ValueTask.
Schedules the continuation action for the .
Schedules the continuation action for the .
Provides an awaiter for a .
The value being awaited.
Initializes the awaiter.
The value to be awaited.
Gets whether the has completed.
Gets the result of the ValueTask.
Schedules the continuation action for this ValueTask.
Schedules the continuation action for this ValueTask.
Provides a value type that wraps a and a ,
only one of which is used.
The type of the result.
Methods may return an instance of this value type when it's likely that the result of their
operations will be available synchronously and when the method is expected to be invoked so
frequently that the cost of allocating a new for each call will
be prohibitive.
There are tradeoffs to using a instead of a .
For example, while a can help avoid an allocation in the case where the
successful result is available synchronously, it also contains two fields whereas a
as a reference type is a single field. This means that a method call ends up returning two fields worth of
data instead of one, which is more data to copy. It also means that if a method that returns one of these
is awaited within an async method, the state machine for that async method will be larger due to needing
to store the struct that's two fields instead of a single reference.
Further, for uses other than consuming the result of an asynchronous operation via await,
can lead to a more convoluted programming model, which can in turn actually
lead to more allocations. For example, consider a method that could return either a
with a cached task as a common result or a . If the consumer of the result
wants to use it as a , such as to use with in methods like Task.WhenAll and Task.WhenAny,
the would first need to be converted into a using
, which leads to an allocation that would have been avoided if a cached
had been used in the first place.
As such, the default choice for any asynchronous method should be to return a or
. Only if performance analysis proves it worthwhile should a
be used instead of . There is no non-generic version of
as the Task.CompletedTask property may be used to hand back a successfully completed singleton in the case where
a -returning method completes synchronously and successfully.
The task to be used if the operation completed asynchronously or if it completed synchronously but non-successfully.
The result to be used if the operation completed successfully synchronously.
Initialize the with the result of the successful operation.
The result.
Initialize the with a that represents the operation.
The task.
Returns the hash code for this instance.
Returns a value indicating whether this value is equal to a specified .
Returns a value indicating whether this value is equal to a specified value.
Returns a value indicating whether two values are equal.
Returns a value indicating whether two values are not equal.
Gets a object to represent this ValueTask. It will
either return the wrapped task object if one exists, or it'll manufacture a new
task object to represent the result.
Gets whether the represents a completed operation.
Gets whether the represents a successfully completed operation.
Gets whether the represents a failed operation.
Gets whether the represents a canceled operation.
Gets the result.
Gets an awaiter for this value.
Configures an awaiter for this value.
true to attempt to marshal the continuation back to the captured context; otherwise, false.
Gets a string-representation of this .