runZoned<R> function

R runZoned <R>(R body(), { Map zoneValues, ZoneSpecification zoneSpecification, @Deprecated("Use runZonedGuarded instead") Function onError })

Runs body in its own zone.

Creates a new zone using Zone.fork based on zoneSpecification and zoneValues, then runs body in that zone and returns the result.

If onError is provided, it must have one of the types

  • void Function(Object)
  • void Function(Object, StackTrace) and the onError handler is used both to handle asynchronous errors by overriding ZoneSpecification.handleUncaughtError in zoneSpecification, if any, and to handle errors thrown synchronously by the call to body.

If an error occurs synchronously in body, then throwing in the onError handler makes the call to runZone throw that error, and otherwise the call to runZoned returns null.

If the zone specification has a handleUncaughtError value or the onError parameter is provided, the zone becomes an error-zone.

Errors will never cross error-zone boundaries by themselves. Errors that try to cross error-zone boundaries are considered uncaught in their originating error zone.

var future = new Future.value(499);
runZoned(() {
  var future2 = future.then((_) { throw "error in first error-zone"; });
  runZoned(() {
    var future3 = future2.catchError((e) { print("Never reached!"); });
  }, onError: (e, s) { print("unused error handler"); });
}, onError: (e, s) { print("catches error of first error-zone."); });

Example:

runZoned(() {
  new Future(() { throw "asynchronous error"; });
}, onError: (e, s) => print(e));  // Will print "asynchronous error".

It is possible to manually pass an error from one error zone to another by re-throwing it in the new zone. If onError throws, that error will occur in the original zone where runZoned was called.

Implementation

R runZoned<R>(R body(),
    {Map zoneValues,
    ZoneSpecification zoneSpecification,
    @Deprecated("Use runZonedGuarded instead") Function onError}) {
  ArgumentError.checkNotNull(body, "body");

  if (onError != null) {
    void Function(Object, StackTrace) typedOnError;
    if (onError is void Function(Object, StackTrace)) {
      typedOnError = onError;
    } else if (onError is void Function(Object)) {
      typedOnError = (Object e, StackTrace _) => onError(e);
    } else {
      throw ArgumentError.value(onError, "onError",
          "Should accept one error, or one error and a stack trace");
    }
    return runZonedGuarded(body, typedOnError,
        zoneValues: zoneValues, zoneSpecification: zoneSpecification);
  }
  return _runZoned<R>(body, zoneValues, zoneSpecification);
}