Gestion des exceptions en Dart

Une exception est un événement d'erreur qui se produit lors de l'exécution d'un programme.

Une bonne gestion des exceptions permet au programme de se dégrader gracieusement lorsqu'il rencontre des erreurs, plutôt que de planter directement.

Ce chapitre présente try/catch/finally en Dart, le lancement d'exceptions avec throw, la capture de types spécifiques avec on, et le relancement avec rethrow.


Bases de try / catch / finally

Le bloc try contient du code susceptible de lever des exceptions, le bloc catch capture et gère les exceptions, et le bloc finally s'exécute indépendamment du fait qu'une exception se produise ou non.

Exemple

void main() {
  // try-catch de base
  try {
    int result = 10 ~/ 0;  // La division par zéro lève une exception
    print(Résultat: $result);  // Cette ligne ne s'exécutera pas
  } catch (e) {
    // e est l'objet exception
    print(Exception capturée: $e);
  }

  // Obtenir les informations sur l'exception et la trace de la pile
  try {
    List<int> numbers = [1, 2, 3];
    print(numbers[10]);  // Accès à un index hors limites
  } catch (e, stackTrace) {
    // e est l'exception, stackTrace est la pile d'appels
    print(EXEMPLE d'exception : $e);
    print(Informations sur la trace de pile :\n$stackTrace');
  }

  // finally : s'exécute indépendamment de la survenue d'une exception
  try {
    print(Tentative d'exécution de l'opération...);
    int result = 5 ~/ 0;
    print(Cette ligne ne s'exécutera pas : $result);
  } catch (e) {
    print(Erreur : $e);
  } finally {
    // Le code dans le bloc finally s'exécute toujours, souvent utilisé pour nettoyer les ressources
    print(Nettoyage des ressources terminé (finally s'exécute toujours));
  }
}
捕获到异常: IntegerDivisionByZeroException
EXAMPLE 异常: RangeError (index): Invalid value: Not in inclusive range 0..2: 10
堆栈信息:
#0      List.[] (dart:core-patch/growable_array.dart:264)
#1      main (file:///...)
...
尝试执行操作...
出错: IntegerDivisionByZeroException
清理资源完成(finally 总是执行)

Le bloc finally est idéal pour le nettoyage des ressources, comme la fermeture de fichiers, la libération de connexions à une base de données, etc. Même s'il y a une instruction return dans try ou catch, finally s'exécute quand même.


throw : Lancer une exception

L'utilisation du mot-clé throw permet de lancer activement une exception.

Dart permet de lancer n'importe quel objet comme exception (pas seulement des sous-classes d'Exception), mais la meilleure pratique est de lancer des sous-classes d'Exception ou d'Error.

Exemple

// Classe d'exception personnalisée
class InvalidAgeException implements Exception {
  final int age;
  final String message;

  InvalidAgeException(this.age)
      : message = Âge invalide : $age (l'âge doit être compris entre 0 et 150);

  @override
  String toString() => 'InvalidAgeException: $message';
}

// Fonction qui utilise une exception personnalisée
void validateAge(int age) {
  if (age < 0) {
    throw InvalidAgeException(age);
  }
  if (age > 150) {
    throw InvalidAgeException(age);
  }
  print(Âge $age validé avec succès);
}

// Lancer une exception intégrée
int divide(int a, int b) {
  if (b == 0) {
    throw ArgumentError(Le diviseur ne peut pas être 0);  // Utiliser une exception intégrée
  }
  return a ~/ b;
}

void main() {
  // Tester une exception personnalisée
  try {
    validateAge(-5);
  } catch (e) {
    print(e);
  }

  try {
    validateAge(200);
  } catch (e) {
    print(e);
  }

  validateAge(25);  // Cas normal

  // Tester le lancement d'une exception intégrée
  try {
    divide(10, 0);
  } catch (e) {
    print(Exemple d'erreur : $e);
  }
}
InvalidAgeException: 无效的年龄: -5(年龄必须在 0 到 150 之间)
InvalidAgeException: 无效的年龄: 200(年龄必须在 0 到 150 之间)
年龄 25 验证通过
EXAMPLE 错误: Invalid argument(s): 除数不能为 0

La différence entre Exception et Error : Exception est une erreur prévisible que le programme peut gérer (comme un délai d'attente réseau, un fichier introuvable) ; Error est un problème imprévisible qui indique généralement un bogue dans le programme (comme des erreurs de type, un pointeur nul). Votre code doit intercepter Exception, et non Error.


on: Intercepter un type spécifié

Le mot-clé on peut intercepter les exceptions par type, ce qui rend la gestion des erreurs plus granulaire.

Exemple

void main() {
  // Intercepter différentes exceptions par type
  try {
    // Simuler différents types d'exceptions
    int result = performOperation('divide_by_zero');
    print(Résultat : $result);
  } on IntegerDivisionByZeroException {
    // Intercepter uniquement l'exception de division par zéro
    print(EXEMPLE erreur : impossible de diviser par zéro);
  } on FormatException catch (e) {
    // Intercepter l'exception de format et obtenir les informations sur l'exception
    print('EXEMPLE erreur de format : ${e.message}');
  } on RangeError {
    // Ne capturer que les erreurs de plage
    print('EXEMPLE erreur : index hors limites');
  } catch (e) {
    // Repli : capturer toutes les autres exceptions
    print('Erreur inconnue : $e');
  } finally {
    print('Opération terminée\n');
  }

  // Exemple de correspondance dans l'ordre
  print('--- Test de différentes opérations ---');
  for (var op in ['divide_by_zero', 'parse_error', 'out_of_range', 'normal']) {
    try {
      performOperation(op);
    } on IntegerDivisionByZeroException {
      print('$op -> exception de division par zéro');
    } on FormatException {
      print('$op -> exception de format');
    } on RangeError {
      print('$op -> exception de plage');
    } catch (e) {
      print('$op -> autre exception : $e');
    }
  }
}

int performOperation(String operation) {
  switch (operation) {
    case 'divide_by_zero':
      return 10 ~/ 0;  // Lancer IntegerDivisionByZeroException
    case 'parse_error':
      int.parse('not_a_number');  // Lancer FormatException
      return 0;
    case 'out_of_range':
      var list = [1, 2, 3];
      return list[100];  // Lancer RangeError
    case 'normal':
      return 42;
    default:
      throw Exception('Opération inconnue');
  }
}
EXAMPLE 错误: 不能除以零
操作结束

--- 测试不同的操作 ---
divide_by_zero -> 除零异常
parse_error -> 格式异常
out_of_range -> 范围异常

L'ordre des on et catch est important : Dart fait correspondre les types d'exception de haut en bas. Les types d'exception plus spécifiques doivent être placés en premier, et les plus généraux en dernier. Si catch (e) est placé au début, les clauses on suivantes ne seront jamais exécutées.


rethrow: Relancer l'exception

Parfois, vous devez effectuer un traitement après avoir attrapé une exception (comme la journalisation), puis laisser l'exception continuer à se propager vers le haut.

Le mot-clé rethrow est utilisé pour relancer l'exception actuellement attrapée, en préservant les informations de pile d'origine.

Exemple

// Simuler un scénario d'appel multicouche
void databaseOperation() {
  print(' Connexion à la base de données...');
  throw Exception('La connexion à la base de données EXAMPLE a échoué');
}

void serviceLayer() {
  try {
    print(' Couche service : appel de l’opération de base de données');
    databaseOperation();
  } catch (e) {
    // Journaliser d’abord, puis relancer
    print(' [Log] exception d’opération de base de données : $e');
    rethrow;  // Préserver l’exception d’origine et la pile, continuer à propager vers le haut
  }
}

void controllerLayer() {
  try {
    print('Couche contrôleur : traitement de la requête');
    serviceLayer();
  } catch (e, stackTrace) {
    // La couche la plus externe intercepte et gère
    print('La couche contrôleur a intercepté une exception');
    print('Message d’erreur : $e');
    print('Retour à l’utilisateur : "Service temporairement indisponible, veuillez réessayer plus tard"');
  }
}

void main() {
  controllerLayer();
  print('\n--- Différence entre rethrow et throw e ---');

  // Démontrer la différence entre rethrow et throw e
  try {
    try {
      throw FormatException('Exception d'origine');
    } catch (e) {
      // throw e : réinitialise la trace de pile, perdant l'emplacement d'appel d'origine
      print('Utilisation de throw e (perd la trace de pile d'origine)...');
      throw e;  // La trace de pile commence ici
    }
  } catch (e, stack) {
    print('Attrapé : $e');
    print('La trace de pile pointe ici (pas l'emplacement d'origine) :\n$stack');
  }
}
控制器层: 处理请求
  服务层: 调用数据库操作
  正在连接数据库...
  [日志] 数据库操作异常: Exception: EXAMPLE 数据库连接失败
控制器层捕获到异常
错误信息: Exception: EXAMPLE 数据库连接失败
给用户返回: "服务暂时不可用,请稍后重试"

--- rethrow vs throw e 的区别 ---
使用 throw e(丢失原始堆栈)...
捕获: FormatException: 原始异常
堆栈指向这里(不是原始位置):
...

La différence entre rethrow et throw e est cruciale : rethrow préserve la trace de pile complète de l'exception d'origine, ce qui facilite la localisation de la cause racine ; throw e réinitialise la pile et repart de la position actuelle. Lorsque vous devez continuer à propager l'exception après l'avoir journalisée, utilisez rethrow.


Bonnes pratiques pour la gestion des exceptions

PratiqueDescription
Ne capturez que les exceptions que vous pouvez gérer.Ne capturez pas aveuglément toutes les exceptions juste pour « éviter les erreurs ». Si vous ne savez pas comment gérer une exception, laissez-la se propager vers le haut.
Capturez par typeUtilisez on pour spécifier le type d'exception, en évitant un seul catch qui avale toutes les exceptions.
finally : Nettoyez les ressourcesLes ressources telles que les fichiers et les connexions réseau doivent être fermées dans finally.
N'avalez pas les exceptionsCapturer une exception et ne rien faire (bloc catch vide) est dangereux ; au minimum, journalisez-la.
Utilisez rethrowLorsque vous devez journaliser et continuer à propager l'exception, utilisez rethrow au lieu de throw e.
Les messages d'exception doivent être spécifiquesthrow Exception('Database connection failed: 192.168.1.1:3306') est plus utile que throw Exception('An error occurred')
autres extensions