Programmation asynchrone en Dart
La programmation asynchrone est l'une des compétences les plus fondamentales du développement d'applications modernes.
Qu'il s'agisse de requêtes réseau, de lecture et d'écriture de fichiers ou d'opérations sur une base de données, un traitement asynchrone est nécessaire pour éviter de bloquer le thread principal.
Ce chapitre présente le concept de Future, la syntaxe async/await et la manière de gérer les erreurs asynchrones.
Pourquoi la programmation asynchrone est nécessaire
Tout d'abord, comprenez la différence entre synchrone et asynchrone.
Le code synchrone s'exécute ligne par ligne, dans l'ordre ; la ligne suivante ne commence pas tant que la ligne précédente n'est pas terminée.
Si une opération doit attendre (comme une requête réseau), tout le programme sera bloqué.
Exemple
Comparez les effets d'exécution du code synchrone et du code asynchrone :
String fetchDataSync() {
// Code synchrone : supposons que nous devions attendre 2 secondes ici
// Pendant ces 2 secondes, tout le programme ne peut rien faire
sleep(Duration(seconds: 2)); // Attente bloquante
return 'Récupération des données terminée';
}
// Version asynchrone : ne bloque pas le thread principal
Future<String> fetchDataAsync() async {
// Attente asynchrone : pendant ces 2 secondes, le programme peut continuer à exécuter d'autres tâches
await Future.delayed(Duration(seconds: 2));
return 'Récupération des données terminée';
}
void main() async {
print('Début de la récupération des données de manière synchrone...');
var syncResult = fetchDataSync();
print('Résultat synchrone : $syncResult');
print('(Remarque : le programme est bloqué pendant l'exécution synchrone)');
print('\n'Début de la récupération des données de manière asynchrone...');
print('Après avoir lancé la requête, le programme continue d'exécuter d'autres tâches...');
var asyncResult = await fetchDataAsync();
print('Résultat asynchrone : $asyncResult');
print('(Remarque : le programme n'est pas bloqué pendant l'exécution asynchrone)');
}
Starting to fetch data synchronously... Synchronous result: Data fetch complete (Note: The program is stuck during synchronous execution) Starting to fetch data asynchronously... After sending the request, the program continues executing other tasks... Asynchronous result: Data fetch complete (The program is not stuck during asynchronous execution)
En Dart, toutes les opérations d'E/S (fichiers, réseau, base de données) doivent utiliser des méthodes asynchrones. Les E/S synchrones bloquent tout l'Isolate, ce qui, dans les applications Flutter, provoque des saccades de l'interface utilisateur.
Le concept de Future
Future
C'est comme une promesse : je n'ai pas de résultat maintenant, mais je vous donnerai certainement une valeur de type T (ou une erreur) dans le futur.
Un Future a trois états :
| State | Description |
|---|---|
| Non complété | L'opération asynchrone est toujours en cours |
| Complété avec des données | L'opération a réussi, et le Future porte la valeur de résultat |
| Complété mais avec des erreurs (Complété avec une erreur) | L'opération échoue, et le Future porte les informations d'erreur. |
Exemple
Création et utilisation d'un Future :
print('Program start');
// Créer un Future
Future<String> future = Future(() {
// Cette fonction s'exécutera à un moment donné dans le futur
return 'EXEMPLE de résultat async';
});
print('Future créé, mais pas encore terminé');
// Enregistrer le callback : exécuter lorsque le Future se termine
future.then((result) {
print('Résultat reçu : $result');
});
print('Le programme continue...');
}
程序开始 Future 已创建,但还没完成 程序继续执行... 收到结果: EXAMPLE 异步结果
Notez l'ordre de la sortie : « le programme continue de s'exécuter » est affiché en premier, et « résultat reçu » est affiché ensuite.
Cela montre que les callbacks de Future sont exécutés de manière asynchrone et ne bloquent pas le code suivant.
syntaxe async / await
async et await sont la syntaxe essentielle pour gérer les opérations asynchrones en Dart.
async marque une fonction comme asynchrone, et await attend qu'un Future se termine et récupère son résultat.
Exemple
// Le type de retour d'une fonction async doit être Future<T>
Future<String> fetchUserName(int id) async {
// await attend que le Future se termine et récupère sa valeur
// Pendant l'attente, la fonction actuelle suspend son exécution, mais ne bloque pas le reste du code
await Future.delayed(Duration(seconds: 1));
return 'User$id';
}
Future<int> fetchUserAge(int id) async {
await Future.delayed(Duration(milliseconds: 500));
return 20 + id;
}
// Exécuter plusieurs opérations asynchrones séquentiellement
Future<void> printUserInfo(int id) async {
print('Début de la récupération des informations utilisateur...');
// Attendre un par un : d'abord récupérer le nom, puis récupérer l'âge
var name = await fetchUserName(id);
print('Nom récupéré : $name');
var age = await fetchUserAge(id);
print('Âge récupéré : $age');
print('EXEMPLE utilisateur : $name, âge : $age');
}
// Exécuter plusieurs opérations asynchrones en parallèle
Future<void> printUserInfoParallel(int id) async {
print(Début de la récupération des informations utilisateur en parallèle...);
// Lancer deux requêtes simultanément sans attendre l'une l'autre
var nameFuture = fetchUserName(id);
var ageFuture = fetchUserAge(id);
// Attendre que les deux requêtes soient terminées
var results = await Future.wait([nameFuture, ageFuture]);
var name = results[0] as String;
var age = results[1] as int;
print(EXEMPLE utilisateur (concurrent): $name, âge: $age);
}
void main() async {
// Exécution séquentielle (temps total ≈ 1s + 0.5s = 1.5s)
await printUserInfo(1);
print('---');
// Exécution concurrente (temps total ≈ max(1s, 0.5s) = 1s)
await printUserInfoParallel(2);
}
开始获取用户信息... 获取到名称: 用户1 获取到年龄: 21 EXAMPLE 用户: 用户1, 年龄: 21 --- 开始并发获取用户信息... EXAMPLE 用户(并发): 用户2, 年龄: 22
Si plusieurs opérations asynchrones n'ont pas de dépendances entre elles, vous devriez utiliser Future.wait pour les exécuter en parallèle au lieu de les attendre une par une. Cela peut considérablement améliorer les performances—le temps total est égal à l'opération la plus lente, et non à la somme de toutes les opérations.
Règles de base d'async/await
| Règles | Description |
|---|---|
| Les fonctions async renvoient un Future | Même si la fonction renvoie T, après avoir utilisé async, elle est automatiquement encapsulée dans Future<T>. |
| await ne peut être utilisé qu'à l'intérieur de fonctions async. | Les fonctions classiques ne peuvent pas utiliser await |
| await met en pause la fonction actuelle | Mais cela ne bloque pas l'exécution d'un autre code |
| await récupère le résultat du Future | Si le Future contient une erreur, await lèvera une exception. |
Appel chaîné then / catchError
En plus de async/await, Dart prend également en charge les appels chaînés avec then() et catchError().
C'est l'écriture traditionnelle de style Promise.
Exemple
Future<String> fetchData(String url) {
return Future.delayed(Duration(seconds: 1), () {
if (url.isEmpty) {
throw Exception(L'URL ne peut pas être vide);
}
return Données de $url;
});
}
void main() {
print(Démarrage de la requête...);
// appel chaîné then / catchError
fetchData('https://example.com/api')
.then((data) {
// Requête réussie
print(Données reçues : $data);
return Traité : $data; // La valeur de retour sera transmise au prochain then
})
.then((traité) {
// Gérer la valeur de retour du then précédent
print(traité);
})
.catchError((erreur) {
// Intercepter toute erreur dans la chaîne de manière uniforme
print(Erreur de requête : $error);
})
.whenComplete(() {
// S'exécute indépendamment du succès ou de l'échec (similaire à finally)
print(Requête terminée (indépendamment du succès ou de l'échec));
});
print(La requête a été envoyée, le programme continue...);
}
开始请求... 请求已发出,程序继续... 获取到数据: 来自 https://example.com/api 的数据 处理后的: 来自 https://example.com/api 的数据 请求结束(无论成功或失败)
Comment choisir entre async/await et then/catchError ?
| Scénarios | Approche recommandée | Raison |
|---|---|---|
| Flux asynchrone linéaire | async/await | Le code est aussi clair que du code synchrone |
| Requêtes multiples simultanées | async/await + Future.wait | Sémantique claire |
| Transformation de données chaînée | then() | Chaque then effectue une étape de transformation, et la chaîne est claire. |
| Callback unique | then() | Plus concis que async/await |
Dans la plupart des cas, async/await est recommandé car il offre une meilleure lisibilité. Mais then() reste utile dans un traitement chaîné simple. Les deux peuvent être mélangés, mais ce n'est pas recommandé — une fonction devrait soit utiliser async/await, soit then/catchError ; les mélanger rend le code difficile à comprendre.
Gestion des erreurs asynchrones
Des erreurs peuvent survenir dans les opérations asynchrones, il faut donc utiliser try-catch pour les gérer.
async/await rend la gestion des erreurs aussi simple que du code synchrone.
Exemple
Future<String> fetchUserProfile(int userId) async {
await Future.delayed(Duration(seconds: 1));
if (userId <= 0) {
throw Exception('ID utilisateur invalide : $userId');
}
if (userId == 404) {
throw HttpException('L’utilisateur n’existe pas');
}
return 'Profil de l’utilisateur $userId';
}
// Exception personnalisée
class HttpException implements Exception {
final String message;
HttpException(this.message);
@override
String toString() => 'HttpException: $message';
}
Future<void> loadUserProfile(int userId) async {
print('Chargement du profil de l’utilisateur $userId...');
try {
var profile = await fetchUserProfile(userId);
print('Chargé avec succès : $profile');
} on HttpException catch (e) {
// Intercepter les erreurs asynchrones spécifiques par type
print('Erreur HTTP : $e');
print('Demander à l’utilisateur : veuillez vérifier si l’utilisateur existe');
} on Exception catch (e) {
// Intercepter les autres exceptions
print('Erreur générale : $e');
} finally {
print('Opération de chargement terminée');
}
}
void main() async {
await loadUserProfile(1); // Succès
print('---');
await loadUserProfile(404); // HttpException
print('---');
await loadUserProfile(-1); // Exception générale
}
正在加载用户 1 的资料... 加载成功: 用户 1 的个人资料 加载操作结束 --- 正在加载用户 404 的资料... HTTP 错误: HttpException: 用户不存在 提示用户:请检查用户是否存在 加载操作结束 --- 正在加载用户 -1 的资料... 一般错误: Exception: 无效的用户 ID: -1 加载操作结束
Règles de gestion des erreurs dans les fonctions asynchrones :
- Si une exception est levée dans une fonction asynchrone, elle sera automatiquement encapsulée dans le Future.
- L'appelant peut utiliser try-catch pour intercepter l'exception depuis await.
- Si then() est utilisé, les exceptions sont transmises à catchError().
- Les exceptions asynchrones non interceptées ne font pas planter le programme, mais elles seront traitées comme une erreur Future non gérée.
autres extensionsN'ignorez jamais les erreurs asynchrones. Chaque appel de fonction asynchrone doit avoir une gestion d'erreur correspondante. Les erreurs asynchrones non gérées impriment des avertissements en mode développement, et peuvent être ignorées silencieusement dans les environnements de production, entraînant des bugs difficiles à traquer.