dart:async

Future<T> class

An object representing a delayed computation.

A Future is used to represent a potential value, or error, that will be available at some time in the future. Receivers of a Future can register callbacks that handle the value or error once it is available. For example:

Future<int> future = getFuture();
future.then((value) => handleValue(value))
      .catchError((error) => handleError(error));

A Future can be completed in two ways: with a value ("the future succeeds") or with an error ("the future fails"). Users can install callbacks for each case.

In some cases we say that a future is completed with another future. This is a short way of stating that the future is completed in the same way, with the same value or error, as the other future once that completes. Whenever a function in the core library may complete a future (for example Completer.complete or new Future.value), then it also accepts another future and does this work for the developer.

The result of registering a pair of callbacks is a new Future (the "successor") which in turn is completed with the result of invoking the corresponding callback. The successor is completed with an error if the invoked callback throws. For example:

Future<int> successor = future.then((int value) {
    // Invoked when the future is completed with a value.
    return 42;  // The successor is completed with the value 42.
  },
  onError: (e) {
    // Invoked when the future is completed with an error.
    if (canHandle(e)) {
      return 499;  // The successor is completed with the value 499.
    } else {
      throw e;  // The successor is completed with the error e.
    }
  });

If a future does not have a successor when it completes with an error, it forwards the error message to the global error-handler. This behavior makes sure that no error is silently dropped. However, it also means that error handlers should be installed early, so that they are present as soon as a future is completed with an error. The following example demonstrates this potential bug:

var future = getFuture();
new Timer(new Duration(milliseconds: 5), () {
  // The error-handler is not attached until 5 ms after the future has
  // been received. If the future fails before that, the error is
  // forwarded to the global error-handler, even though there is code
  // (just below) to eventually handle the error.
  future.then((value) { useValue(value); },
              onError: (e) { handleError(e); });
});

When registering callbacks, it's often more readable to register the two callbacks separately, by first using then with one argument (the value handler) and using a second catchError for handling errors. Each of these will forward the result that they don't handle to their successors, and together they handle both value and error result. It also has the additional benefit of the catchError handling errors in the then value callback too. Using sequential handlers instead of parallel ones often leads to code that is easier to reason about. It also makes asynchronous code very similar to synchronous code:

// Synchronous code.
try {
  int value = foo();
  return bar(value);
} catch (e) {
  return 499;
}

Equivalent asynchronous code, based on futures:

Future<int> future = new Future(foo);  // Result of foo() as a future.
future.then((int value) => bar(value))
      .catchError((e) => 499);

Similar to the synchronous code, the error handler (registered with catchError) is handling any errors thrown by either foo or bar. If the error-handler had been registered as the onError parameter of the then call, it would not catch errors from the bar call.

Futures can have more than one callback-pair registered. Each successor is treated independently and is handled as if it was the only successor.

A future may also fail to ever complete. In that case, no callbacks are called.

Constructors

Future(FutureOr<T> computation())

factory

Creates a future containing the result of calling computation asynchronously with Timer.run. [...]

Future.delayed(Duration duration, [ FutureOr<T> computation() ])

factory

Creates a future that runs its computation after a delay. [...]

Future.error(Object error, [ StackTrace stackTrace ])

factory

Creates a future that completes with an error. [...]

Future.microtask(FutureOr<T> computation())

factory

Creates a future containing the result of calling computation asynchronously with scheduleMicrotask. [...]

Future.sync(FutureOr<T> computation())

factory

Returns a future containing the result of immediately calling computation. [...]

Future.value([FutureOr<T> value ])

factory

Creates a future completed with value. [...]

Properties

hashCode → int

read-only, inherited

The hash code for this object. [...]

runtimeType → Type

read-only, inherited

A representation of the runtime type of the object.

Methods

asStream() → Stream<T>

Creates a Stream containing the result of this future. [...]

catchError(Function onError, { bool test(Object error) }) → Future<T>

Handles errors emitted by this Future. [...]

then<R>(FutureOr<R> onValue(T value), { Function onError }) → Future<R>

Register callbacks to be called when this future completes. [...]

timeout(Duration timeLimit, { FutureOr<T> onTimeout() }) → Future<T>

Time-out the future computation after timeLimit has passed. [...]

whenComplete(FutureOr action()) → Future<T>

Registers a function to be called when this future completes. [...]

noSuchMethod(Invocation invocation) → dynamic

inherited

Invoked when a non-existent method or property is accessed. [...]

toString() → String

inherited

Returns a string representation of this object.

Operators

operator ==(dynamic other) → bool

inherited

The equality operator. [...]

Static Methods

any<T>(Iterable<Future<T>> futures) → Future<T>

Returns the result of the first future in futures to complete. [...]

doWhile(FutureOr<bool> action()) → Future

Performs an operation repeatedly until it returns false. [...]

forEach<T>(Iterable<T> elements, FutureOr action(T element)) → Future

Performs an action for each element of the iterable, in turn. [...]

wait<T>(Iterable<Future<T>> futures, { bool eagerError: false, void cleanUp(T successValue) }) → Future<List<T>>

Waits for multiple futures to complete and collects their results. [...]