メニュー
Add the Throttle mixin to prevent actions from running too frequently. Covers setting the throttle duration in milliseconds, use cases like price refresh, and how freshness/staleness works.
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-throttle-mixin |
| description | Add the Throttle mixin to prevent actions from running too frequently. Covers setting the throttle duration in milliseconds, use cases like price refresh, and how freshness/staleness works. |
The Throttle mixin limits action execution to at most once per throttle period. When an action is dispatched multiple times within the defined window, only the first execution runs while subsequent calls abort silently. After the period expires, the next dispatch is permitted.
class LoadPrices extends AppAction with Throttle {
// Throttle period in milliseconds (default is 1000ms)
int get throttle => 5000; // 5 seconds
Future<AppState?> reduce() async {
var prices = await fetchCurrentPrices();
return state.copy(prices: prices);
}
}
The default throttle duration is 1000 milliseconds (1 second). Override the throttle getter to set a custom duration.
Throttle uses a "freshness window" concept:
This ensures that frequently triggered actions (like a "Refresh Prices" button) don't overwhelm your server while still allowing updates after a reasonable interval.
// User taps "Refresh" rapidly 5 times in 2 seconds
// With a 5-second throttle:
// - 1st tap: Action runs, prices update
// - 2nd-5th taps: Silently aborted (data still "fresh")
// - Tap after 5 seconds: Action runs again (data now "stale")
| Aspect | Throttle | Debounce |
|---|---|---|
| When it runs | Immediately on first dispatch | After dispatches stop |
| Blocking | Blocks for the period after running | Resets timer on each dispatch |
| Use case | Price refresh, rate-limited APIs | Search-as-you-type |
Override ignoreThrottle to conditionally skip rate limiting:
class LoadPrices extends AppAction with Throttle {
final bool forceRefresh;
LoadPrices({this.forceRefresh = false});
int get throttle => 5000;
// Bypass throttle when force refresh is requested
bool get ignoreThrottle => forceRefresh;
Future<AppState?> reduce() async {
var prices = await fetchCurrentPrices();
return state.copy(prices: prices);
}
}
// Normal dispatch - respects throttle
dispatch(LoadPrices());
// Force refresh - ignores throttle
dispatch(LoadPrices(forceRefresh: true));
By default, the throttle lock persists even after errors, preventing immediate retry:
class LoadPrices extends AppAction with Throttle {
int get throttle => 5000;
// Allow immediate retry if the action fails
bool get removeLockOnError => true;
Future<AppState?> reduce() async {
var prices = await fetchCurrentPrices();
return state.copy(prices: prices);
}
}
For more control, use these methods:
// Remove the lock for this specific action type
removeLock();
// Remove locks for all throttled actions
removeAllLocks();
Override lockBuilder() to implement different locking behaviors:
class LoadPricesForSymbol extends AppAction with Throttle {
final String symbol;
LoadPricesForSymbol(this.symbol);
int get throttle => 5000;
// Use the symbol as part of the lock key
// This allows throttling per symbol instead of per action type
Object lockBuilder() => 'LoadPrices_$symbol';
Future<AppState?> reduce() async {
var price = await fetchPrice(symbol);
return state.copy(prices: state.prices.add(symbol, price));
}
}
// These can run in parallel (different lock keys):
dispatch(LoadPricesForSymbol('AAPL'));
dispatch(LoadPricesForSymbol('GOOGL'));
// But this will be throttled (same lock key as first):
dispatch(LoadPricesForSymbol('AAPL')); // Aborted if within 5 seconds
class RefreshStockPrices extends AppAction with Throttle {
int get throttle => 10000; // At most once every 10 seconds
Future<AppState?> reduce() async {
var prices = await stockApi.getAllPrices();
return state.copy(stockPrices: prices);
}
}
class SyncWithServer extends AppAction with Throttle {
int get throttle => 30000; // At most once every 30 seconds
Future<AppState?> reduce() async {
var data = await api.sync();
return state.copy(lastSync: DateTime.now(), data: data);
}
}
class SubmitFeedback extends AppAction with Throttle {
final String feedback;
SubmitFeedback(this.feedback);
int get throttle => 60000; // At most once per minute
Future<AppState?> reduce() async {
await api.submitFeedback(feedback);
return state.copy(feedbackSubmitted: true);
}
}
Compatible with:
CheckInternetNoDialogAbortWhenNoInternetRetryUnlimitedRetriesDebounceIncompatible with:
NonReentrant (use one or the other, not both)OptimisticUpdateOptimisticSyncOptimisticSyncWithPushclass LoadPrices extends AppAction
with CheckInternet, Throttle, Retry {
int get throttle => 5000;
Future<AppState?> reduce() async {
// CheckInternet ensures connectivity
// Throttle prevents excessive calls
// Retry handles transient failures
var prices = await fetchCurrentPrices();
return state.copy(prices: prices);
}
}
URLs from the documentation: