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 :

// Simuler une opération chronophage
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

FutureReprésente une valeur qui « s'achèvera à un moment donné dans le futur ».

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 :

StateDescription
Non complétéL'opération asynchrone est toujours en cours
Complété avec des donnéesL'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 :

void main() {
  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 mot-clé async marque une fonction comme une fonction asynchrone
// 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èglesDescription
Les fonctions async renvoient un FutureMê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 actuelleMais cela ne bloque pas l'exécution d'un autre code
await récupère le résultat du FutureSi 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

// Fonction pour simuler une requête réseau
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énariosApproche recommandéeRaison
Flux asynchrone linéaireasync/awaitLe code est aussi clair que du code synchrone
Requêtes multiples simultanéesasync/await + Future.waitSémantique claire
Transformation de données chaînéethen()Chaque then effectue une étape de transformation, et la chaîne est claire.
Callback uniquethen()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

// Simuler une requête réseau qui peut échouer
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.

N'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.

autres extensions