菜单
Dispatch actions using all available methods: `dispatch()`, `dispatchAndWait()`, `dispatchAll()`, `dispatchAndWaitAll()`, and `dispatchSync()`. Covers dispatching from widgets via context extensions and from within other actions.
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
基于 SOC 职业分类
Inject dependencies into actions using the environment, dependencies, and configuration pattern. Covers creating an Environment enum, a Dependencies class, passing them to the Store, accessing them from actions and widgets, and using dependency injection for testability.
Create a custom base action class for your app. Covers adding getter shortcuts to state parts, adding selector methods, implementing shared wrapError logic, and establishing project-wide action conventions.
Initialize, setup and configure AsyncRedux in a Flutter app. Use it whenever starting a new AsyncRedux project, or when the user requests.
Stops an AsyncRedux (Flutter) action from dispatching. Use only when the user mentions abortDispatch(), or explicitly asks to abort or prevent dispatch under certain conditions.
Checks an AsyncRedux (Flutter) action's completion status using ActionStatus right after the dispatch returns. Use only when you need to know whether an action completed, whether it failed with an error, what error it produced, or how to navigate based on success or failure.
Creates AsyncRedux (Flutter) actions that return null from reduce() to not change the state. Such actions can still do side effects, dispatch other actions, or do nothing.
| name | asyncredux-dispatching-actions |
| description | Dispatch actions using all available methods: `dispatch()`, `dispatchAndWait()`, `dispatchAll()`, `dispatchAndWaitAll()`, and `dispatchSync()`. Covers dispatching from widgets via context extensions and from within other actions. |
The foundational principle of AsyncRedux: the only way to change the application state is by dispatching actions. You can dispatch from widgets (via context extensions) or from within other actions.
The standard method that returns immediately. For synchronous actions, state updates before return; for async actions, the process begins and completes later.
dispatch(MyAction());
Returns a Future that completes when the action finishes and state changes, regardless of whether the action is sync or async. Returns an ActionStatus object.
var status = await dispatchAndWait(MyAction());
if (status.isCompletedOk) {
Navigator.pop(context);
}
Dispatches multiple actions in parallel, returning the list of dispatched actions.
dispatchAll([BuyAction('IBM'), SellAction('TSLA')]);
Dispatches actions in parallel and waits for all to complete.
await dispatchAndWaitAll([
BuyAction('IBM'),
SellAction('TSLA'),
]);
Like dispatch() but throws a StoreException if the action is asynchronous. Use when synchronous execution is mandatory.
dispatchSync(MyAction());
All dispatch methods are available as BuildContext extensions:
context.dispatch(Action());
context.dispatchAll([Action1(), Action2()]);
await context.dispatchAndWait(Action());
await context.dispatchAndWaitAll([Action1(), Action2()]);
context.dispatchSync(Action());
Example button implementation:
ElevatedButton(
onPressed: () => context.dispatch(Increment()),
child: Text('Increment'),
)
For async dispatch in callbacks:
ElevatedButton(
onPressed: () async {
var status = await context.dispatchAndWait(SaveAction());
if (status.isCompletedOk) {
Navigator.pop(context);
}
},
child: Text('Save'),
)
All dispatch methods are available inside actions via the ReduxAction base class:
class MyAction extends ReduxAction<AppState> {
Future<AppState?> reduce() async {
// Dispatch another action and wait for it
await dispatchAndWait(LoadDataAction());
// Dispatch without waiting
dispatch(LogAction('Data loaded'));
return state.copy(loaded: true);
}
}
You can dispatch actions in the before() and after() lifecycle methods:
class MyAction extends ReduxAction<AppState> {
Future<AppState?> reduce() async {
String description = await fetchData();
return state.copy(description: description);
}
void before() => dispatch(BarrierAction(true));
void after() => dispatch(BarrierAction(false));
}
The dispatchAndWait() method returns an ActionStatus object with useful properties:
var status = await dispatchAndWait(MyAction());
// Check completion state
status.isCompleted; // Action finished executing
status.isCompletedOk; // Completed without errors
status.isCompletedFailed; // Completed with errors
// Access error information
status.originalError; // Error thrown by before/reduce
status.wrappedError; // Error after wrapError() processing
// Check method completion
status.hasFinishedMethodBefore;
status.hasFinishedMethodReduce;
status.hasFinishedMethodAfter;
You can also access status directly from the action instance:
var action = MyAction();
await dispatchAndWait(action);
print(action.status.isCompletedOk);
Dispatch methods accept an optional notify parameter (default true) that controls whether widgets rebuild on state changes:
// Dispatch without triggering widget rebuilds
dispatch(MyAction(), notify: false);
| Method | Returns | Waits? | Use Case |
|---|---|---|---|
dispatch() | void | No | Fire and forget |
dispatchAndWait() | Future<ActionStatus> | Yes | Need to know when done |
dispatchAll() | List<ReduxAction> | No | Multiple parallel actions |
dispatchAndWaitAll() | Future<void> | Yes | Wait for all parallel actions |
dispatchSync() | void | N/A | Enforce sync execution |
URLs from the documentation: