【Flutter】FutureBuilder 异步编程 ( FutureBuilder 构造方法 | AsyncSnapshot 异步计算 )

/// Creates a widget that builds itself based on the latest snapshot of
/// interaction with a [Future].
///
/// The [builder] must not be null.
const FutureBuilder({
  Key? key,
  this.future,
  this.initialData,
  required this.builder,
}) : assert(builder != null),
     super(key: key);
FutureBuilder({Key key, Future<T> future, T initialData, @required AsyncWidgetBuilder<T> builder })

  /// The asynchronous computation to which this builder is currently connected,

/// possibly null.

///

/// If no future has yet completed, including in the case where [future] is

/// null, the data provided to the [builder] will be set to [initialData].

final Future<T>? future;

  /// The data that will be used to create the snapshots provided until a

/// non-null [future] has completed.

///

/// If the future completes with an error, the data in the [AsyncSnapshot]

/// provided to the [builder] will become null, regardless of [initialData].

/// (The error itself will be available in [AsyncSnapshot.error], and

/// [AsyncSnapshot.hasError] will be true.)

final T? initialData;

/// Signature for strategies that build widgets based on asynchronous

/// interaction.

///

/// See also:

///

///  * [StreamBuilder], which delegates to an [AsyncWidgetBuilder] to build

///    itself based on a snapshot from interacting with a [Stream].

///  * [FutureBuilder], which delegates to an [AsyncWidgetBuilder] to build

///    itself based on a snapshot from interacting with a [Future].

typedef AsyncWidgetBuilder<T> = Widget Function(BuildContext context, AsyncSnapshot<T> snapshot);

class AsyncSnapshot<T> {

/// Creates an [AsyncSnapshot] with the specified [connectionState],

/// and optionally either [data] or [error] with an optional [stackTrace]

/// (but not both data and error).

const AsyncSnapshot._(this.connectionState, this.data, this.error, this.stackTrace)

: assert(connectionState != null),

assert(!(data != null && error != null)),

assert(stackTrace == null || error != null);

/// Current state of connection to the asynchronous computation.

final ConnectionState connectionState;
/// The latest data received by the asynchronous computation.

///

/// If this is non-null, [hasData] will be true.

///

/// If [error] is not null, this will be null. See [hasError].

///

/// If the asynchronous computation has never returned a value, this may be

/// set to an initial data value specified by the relevant widget. See

/// [FutureBuilder.initialData] and [StreamBuilder.initialData].

final T? data;
/// The latest error object received by the asynchronous computation.

///

/// If this is non-null, [hasError] will be true.

///

/// If [data] is not null, this will be null.

final Object? error;
/// Returns whether this snapshot contains a non-null [data] value.

///

/// This can be false even when the asynchronous computation has completed

/// successfully, if the computation did not return a non-null value. For

/// example, a [Future<void>] will complete with the null value even if it

/// completes successfully.

bool get hasData => data != null;
/// Returns whether this snapshot contains a non-null [error] value.

///

/// This is always true if the asynchronous computation's last result was

/// failure.

bool get hasError => error != null;

}

/// The state of connection to an asynchronous computation.

///

/// The usual flow of state is as follows:

///

/// 1. [none], maybe with some initial data.

/// 2. [waiting], indicating that the asynchronous operation has begun,

///    typically with the data being null.

/// 3. [active], with data being non-null, and possible changing over time.

/// 4. [done], with data being non-null.

///

/// See also:

///

///  * [AsyncSnapshot], which augments a connection state with information

///    received from the asynchronous computation.

enum ConnectionState {

/// Not currently connected to any asynchronous computation.

///

/// For example, a [FutureBuilder] whose [FutureBuilder.future] is null.

none,

/// Connected to an asynchronous computation and awaiting interaction.

waiting,
/// Connected to an active asynchronous computation.

///

/// For example, a [Stream] that has returned at least one value, but is not

/// yet done.

active,
/// Connected to a terminated asynchronous computation.

done,

}

  /// Returns whether this snapshot contains a non-null [data] value.

///

/// This can be false even when the asynchronous computation has completed

/// successfully, if the computation did not return a non-null value. For

/// example, a [Future<void>] will complete with the null value even if it

/// completes successfully.

bool get hasData => data != null;

/// Returns whether this snapshot contains a non-null [error] value.

///

/// This is always true if the asynchronous computation's last result was

/// failure.

bool get hasError => error != null;