/* Page prose (fr) */
"TakingOverTheStateMachine" = "# Prendre le contrôle de la machine à états\n\nUne `Operation` se déplace à travers une petite **machine à états**: `ready` → `executing` → `finished`.\n\n* **ready**: dépendances satisfaites, en attente de son tour.\n* **executing**: en cours d'exécution.\n* **finished**: terminé (qu'elle ait abouti ou été annulée).\n\nPour une opération normale, Foundation pilote ces transitions pour toi et bascule vers **finished** dès que `main()` retourne. Pour le travail basé sur les callbacks, tu dois maintenir l'opération en **executing** jusqu'à ce que le callback se déclenche, donc tu dois piloter les transitions toi-même.\n\nFoundation surveille trois propriétés en lecture seule (`isReady`, `isExecuting`, `isFinished`) en utilisant **KVO** (Key-Value Observing), le mécanisme d'Objective-C où un objet annonce \"cette propriété est sur le point de changer / vient de changer\" pour que les observateurs puissent réagir. Une `OperationQueue` observe `isFinished`; c'est ainsi qu'elle apprend qu'une opération est terminée et peut démarrer la prochaine dépendante. Donc quand tu bascules ces états à la main, tu dois **déclencher les notifications KVO** (`willChangeValue(forKey:)` avant, `didChangeValue(forKey:)` après) ou la file ne l'apprend jamais.\n\nIl y a une pièce de plus. Tu surcharges `isAsynchronous` pour qu'elle retourne `true`. C'est ta promesse à Foundation: *\"ne suppose pas que je suis terminée quand `start()` retourne; surveille `isFinished`, je la basculerai moi-même.\"* Voici une petite classe de base réutilisable qui fait exactement cela:";
"TakingOverTheStateMachine-2" = "Lis `start()` attentivement. Si l'opération a été annulée avant de commencer, on va directement à **finished** sans exécuter `main()`. Sinon, on passe à **executing** et on appelle `main()`, mais on ne termine *pas* ici. L'opération reste en **executing** jusqu'à ce que quelqu'un appelle `finish()`, qui la fait passer à **finished** et déclenche la notification KVO que la file attend.\n\nMaintenant l'envoi devient correct. Une sous-classe surcharge `main()`, démarre le travail asynchrone, et appelle `finish()` depuis le callback:";
"TakingOverTheStateMachine-3" = "**Observe l'exécution:** maintenant l'ordre est `⬆️ Uploading...`, puis une seconde plus tard `✅ ... reached the print server`, et *seulement ensuite* `🎉 completionBlock`. L'opération est restée en **executing** toute la seconde, exactement comme elle le devait. Si cet envoi avait une opération dépendante, elle attendrait maintenant la vraie fin, pas la fin prématurée.\n\n* callout(Essaie): Commente les appels à `self.finish()` dans le callback et exécute: la ligne `🎉 completionBlock` n'apparaît jamais, parce que l'opération ne quitte jamais **executing**.\n\n> **La seule règle que tu ne peux pas enfreindre:** une opération asynchrone doit *toujours* atteindre **finished**, sur tous les chemins: succès *et* annulation. C'est pourquoi la branche d'annulation ci-dessus appelle quand même `finish()`. Oublie-le et l'opération reste bloquée en **executing** pour toujours, coinçant la file derrière elle comme un bourrage papier qui ne se dégage jamais.\n\n[Précédent](@previous)  |  page 5 sur 7  |  [Suivant: completionBlock, en bref](@next)";
