Struct Task 

pub struct Task<T> { /* private fields */ }

The outcome of an asynchronous operation (Task<TResult>; Task is Task<()>): a shared handle that ends once, with a result, an error or a cancellation.

Continuations (continue_with) run synchronously when the task ends (TaskContinuationOptions.ExecuteSynchronously); a task is also a Future of its outcome. Tasks belong to the thread that made them, like the observables (docs/porting/reactive.md, section 5.8).

Implementations

impl<T: 'static> Task<T>

pub fn from_result(result: T) -> Self

A task that has ended with result (Task.FromResult).

pub fn from_exception(error: ObservableError) -> Self

A task that has ended with error (Task.FromException); a TaskCanceledError makes it canceled.

pub fn from_canceled() -> Self

A canceled task (Task.FromCanceled).

pub fn spawn_local( future: impl Future<Output = Result<T, ObservableError>> + 'static, ) -> Self

Runs future on the current thread and gives its task (the counterpart of an async method): see spawn_local.

pub fn id(&self) -> u64

The identity of the task (Id).

pub fn status(&self) -> TaskStatus

The state of the task (Status).

pub fn is_completed(&self) -> bool

Whether the task has ended, in any way (IsCompleted).

pub fn is_completed_successfully(&self) -> bool

Whether the task has ended with a result (IsCompletedSuccessfully).

pub fn is_faulted(&self) -> bool

Whether the task has ended with an error (IsFaulted).

pub fn is_canceled(&self) -> bool

Whether the task has been canceled (IsCanceled).

pub fn exception(&self) -> Option<ObservableError>

The error of a faulted task (Exception, unwrapped from its AggregateException).

pub fn result(&self) -> Result<T, ObservableError>

where T: Clone,

The outcome of an ended task: the result, the error of a faulted task, or a TaskCanceledError (Result, GetAwaiter().GetResult()).

Panics

When the task has not ended: upstream blocks, which would deadlock the only thread.

pub fn continue_with( &self, continuation: impl FnOnce(&Task<T>) + 'static, ) -> Option<ContinuationId>

Runs continuation when the task ends, synchronously on the thread that ends it, or at once when it has ended (ContinueWith with TaskContinuationOptions.ExecuteSynchronously). The id removes a continuation that has not run (remove_continuation, the cancellation token of ContinueWith); None when it ran at once.

pub fn remove_continuation(&self, id: ContinuationId) -> bool

Removes a continuation that has not run; false when it has run or was removed.

Trait Implementations

impl<T> Clone for Task<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for Task<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Clone + 'static> Future for Task<T>

type Output = Result<T, Rc<dyn Error>>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.