description

# Zone class abstract final

A zone represents an environment that remains stable across asynchronous calls.

All code is executed in the context of a zone, available to the code as Zone.current. The initial `main` function runs in the context of the default zone (Zone.root). Code can be run in a different zone using either runZoned or runZonedGuarded to create a new zone and run code in it, or Zone.run to run code in the context of an existing zone which may have been created earlier using Zone.fork.

Developers can create a new zone that overrides some of the functionality of an existing zone. For example, custom zones can replace or modify the behavior of `print`, timers, microtasks or how uncaught errors are handled.

The Zone class is not subclassable, but users can provide custom zones by forking an existing zone (usually Zone.current) with a ZoneSpecification. This is similar to creating a new class that extends the base `Zone` class and that overrides some methods, except without actually creating a new class. Instead the overriding methods are provided as functions that explicitly take the equivalent of their own class, the "super" class and the `this` object as parameters.

Asynchronous callbacks always run in the context of the zone where they were scheduled. This is implemented using two steps:

1. the callback is first registered using one of registerCallback, registerUnaryCallback, or registerBinaryCallback. This allows the zone to record that a callback exists and potentially modify it (by returning a different callback). The code doing the registration (e.g., `Future.then`) also remembers the current zone so that it can later run the callback in that zone.
2. At a later point the registered callback is run in the remembered zone, using one of run, runUnary or runBinary.

This is all handled internally by the platform code and most users don't need to worry about it. However, developers of new asynchronous operations, provided by the underlying system, must follow the protocol to be zone compatible.

For convenience, zones provide bindCallback (and the corresponding bindUnaryCallback and bindBinaryCallback) to make it easier to respect the zone contract: these functions first invoke the corresponding `register` functions and then wrap the returned function so that it runs in the current zone when it is later asynchronously invoked.

Similarly, zones provide bindCallbackGuarded (and the corresponding bindUnaryCallbackGuarded and bindBinaryCallbackGuarded), when the callback should be invoked through Zone.runGuarded.

Annotations
  - @vmIsolateUnsendable

## Properties

errorZone → Zone
  The error zone is responsible for dealing with uncaught errors.
  no setter
hashCode → int
  The hash code for this object.
  no setterinherited
parent → Zone?
  The parent zone of the this zone.
  no setter
runtimeType → Type
  A representation of the runtime type of the object.
  no setterinherited

## Methods

bindBinaryCallback<R, T1, T2>(R callback(T1 argument1, T2 argument2)) → ZoneBinaryCallback<R, T1, T2>
  Registers the provided `callback` and returns a function that will execute in this zone.
bindBinaryCallbackGuarded<T1, T2>(void callback(T1 argument1, T2 argument2)) → void Function(T1 argument1, T2 argument2)
  Registers the provided `callback` and returns a function that will execute in this zone.
bindCallback<R>(R callback()) → ZoneCallback<R>
  Registers the provided `callback` and returns a function that will execute in this zone.
bindCallbackGuarded(void callback()) → void Function()
  Registers the provided `callback` and returns a function that will execute in this zone.
bindUnaryCallback<R, T>(R callback(T argument)) → ZoneUnaryCallback<R, T>
  Registers the provided `callback` and returns a function that will execute in this zone.
bindUnaryCallbackGuarded<T>(void callback(T argument)) → void Function(T argument)
  Registers the provided `callback` and returns a function that will execute in this zone.
createPeriodicTimer(Duration period, void callback(Timer timer)) → Timer
  Creates a periodic Timer where the callback is executed in this zone.
createTimer(Duration duration, void callback()) → Timer
  Creates a Timer where the callback is executed in this zone.
errorCallback(Object error, StackTrace? stackTrace) → AsyncError?
  Intercepts errors when added programmatically to a Future or Stream.
fork({ZoneSpecification? specification, Map<Object?, Object?>? zoneValues}) → Zone
  Creates a new zone as a child zone of this zone.
handleUncaughtError(Object error, StackTrace stackTrace) → void
  Handles uncaught asynchronous errors.
inSameErrorZone(Zone otherZone) → bool
  Whether this zone and `otherZone` are in the same error zone.
noSuchMethod(Invocation invocation) → dynamic
  Invoked when a nonexistent method or property is accessed.
  inherited
print(String line) → void
  Prints the given `line`.
registerBinaryCallback<R, T1, T2>(R callback(T1 arg1, T2 arg2)) → ZoneBinaryCallback<R, T1, T2>
  Registers the given callback in this zone.
registerCallback<R>(R callback()) → ZoneCallback<R>
  Registers the given callback in this zone.
registerUnaryCallback<R, T>(R callback(T arg)) → ZoneUnaryCallback<R, T>
  Registers the given callback in this zone.
run<R>(R action()) → R
  Executes `action` in this zone.
runBinary<R, T1, T2>(R action(T1 argument1, T2 argument2), T1 argument1, T2 argument2) → R
  Executes the given `action` with `argument1` and `argument2` in this zone.
runBinaryGuarded<T1, T2>(void action(T1 argument1, T2 argument2), T1 argument1, T2 argument2) → void
  Executes the given `action` with `argument1` and `argument2` in this zone and catches synchronous errors.
runGuarded(void action()) → void
  Executes the given `action` in this zone and catches synchronous errors.
runUnary<R, T>(R action(T argument), T argument) → R
  Executes the given `action` with `argument` in this zone.
runUnaryGuarded<T>(void action(T argument), T argument) → void
  Executes the given `action` with `argument` in this zone and catches synchronous errors.
scheduleMicrotask(void callback()) → void
  Runs `callback` asynchronously in this zone.
toString() → String
  A string representation of this object.
  inherited

## Operators

operator ==(Object other) → bool
  The equality operator.
  inherited
operator [](Object? key) → dynamic
  Retrieves the zone-value associated with `key`.

## Static Properties

current → Zone
  The zone that is currently active.
  no setter

## Constants

root → const Zone
  The root zone.