Vous chargerez des données distantes dans l’UI sans courses entre réponses obsolètes et fraîches, et vous exécuterez du travail d’arrière-plan sur le runtime asynchrone natif du framework.
Prérequis : une installation Quoin fonctionnelle et un contexte qui implémente ReactiveContext (voir Écrire des hooks portables).
Charger des données avec une ressource
Section intitulée « Charger des données avec une ressource »cx.create_resource donne à chaque adaptateur le cycle de vie de données asynchrones familier de Leptos et Dioxus : Idle → Loading → Ready(T) | Failed(E). Passez une fermeture qui reçoit un CancellationToken et renvoie un future :
let user = cx.create_resource(|token| async move { // Vérifiez le jeton entre les awaits pour que les rechargements arrêtent le travail obsolète : Ok::<User, FetchError>(fetch_user(&token).await?)});
// N'importe où dans l'UI :match user.state().get() { ResourceState::Ready(user) => render_user(&user), ResourceState::Loading => render_spinner(), ResourceState::Failed(err) => render_error(&err), ResourceState::Idle => render_placeholder(),}La ressource gère les deux problèmes qui hantent les boucles de fetch écrites à la main :
- Rechargements exempts de courses — chaque rechargement incrémente un compteur de génération, donc une requête obsolète ne peut jamais écraser un résultat plus récent.
- Annulation coopérative — recharger annule la requête en vol via son jeton et abandonne la tâche via le handle de join de l’exécuteur.
Appelez user.reload_with(&cx, fetch) pour réexécuter la fermeture de fetch ; l’état revient à Loading jusqu’à ce que la nouvelle requête se règle.
Lancer des tâches ponctuelles
Section intitulée « Lancer des tâches ponctuelles »Pour un travail qui n’est pas lié à une ressource, lancez sur le runtime du framework avec l’exécuteur :
let handle = cx.executor().spawn(async { let data = fetch_from_api().await; signal.set(data);});
// Plus tard : attendre le résultat (Err(Canceled) si abandonné), abort(), ou detach().Chaque adaptateur implémente le même cycle de vie de handle de join :
| Opération | Effet |
|---|---|
handle.await |
Attend le résultat ; la tâche s’exécute jusqu’à complétion. |
handle.abort() |
Annule au prochain point de suspension ; les awaits ultérieurs se résolvent avec Err(Canceled). |
handle.detach() |
Fire-and-forget ; la tâche s’exécute jusqu’à complétion, son résultat est jeté. |
drop(handle) |
Annule la tâche — concurrence structurée, aucune tâche orpheline mutant l’état UI. |
L’annulation est coopérative sur les adaptateurs à base de threads (Leptos, Dioxus, Floem) : le future s’arrête à son prochain point .await. GPUI et Xilem annulent nativement.
Fetch-and-cancel en un appel
Section intitulée « Fetch-and-cancel en un appel »spawn_with_token (de ExecutorExt, dans le prelude) crée un jeton d’annulation et le remet à votre future :
let (handle, token) = cx.executor().spawn_with_token(|t| async move { while !t.is_cancelled() { do_work().await; }});// L'utilisateur a navigué ailleurs :token.cancel();Exécuter des futures !Send avec spawn_local
Section intitulée « Exécuter des futures !Send avec spawn_local »Les navigateurs exécutent WASM sur un seul thread et la plupart des futures qui touchent le DOM sont !Send. La machinerie LocalExecutor couvre les deux mondes :
use quoin_core::LocalExecutor;
cx.executor().spawn_local(async { update_dom().await });- Sur
wasm32, les tâches tournent sur le thread principal du navigateur viawasm_bindgen_futures. - En natif, les tâches entrent dans une file FIFO thread-locale déterministe pilotée par
quoin_core::local::run_local_tasks()— utile dans les tests.
Dormir sans runtime asynchrone
Section intitulée « Dormir sans runtime asynchrone »Les minuteurs font partie du contrat d’exécuteur. executor.sleep(duration) renvoie un future sur chaque adaptateur (futures-timer en natif, minuteurs de navigateur sur WASM), et la fonction libre quoin_core::sleep vous donne un SyncSleepFuture autonome :
cx.executor().sleep(Duration::from_millis(250)).await;Étapes suivantes
Section intitulée « Étapes suivantes »-
Annuler du travailJetons enfants, gardes RAII et course du travail contre l'annulation.
-
Référence des ressourcesL'API complète de Resource et ResourceState.
-
Référence des exécuteurs et tâchesSpawn, handles de join, tâches locales et minuteurs.
