Module Dart.9 – Gestion des erreurs

Objectif

Maîtriser la gestion des erreurs Dart : try/catch/finally, exceptions personnalisées pour créer des applications robustes.

Théorie

try/catch/finally

Structure de base pour gérer les erreurs.

try {
    // Code qui peut générer une exception
    int resultat = diviser(10, 0);
} on IntegerDivisionByZeroException {
    // Gestion spécifique
    print('Division par zéro');
} catch (e) {
    // Gestion générale
    print('Erreur : $e');
} finally {
    // Code toujours exécuté
    print('Nettoyage');
}

Types d'exceptions

Exceptions courantes

// FormatException
int.parse('abc');  // FormatException

// RangeError
List<int> nombres = [1, 2, 3];
nombres[10];  // RangeError

// NoSuchMethodError
dynamic obj = null;
obj.methode();  // NoSuchMethodError

// ArgumentError
void fonction(int valeur) {
    if (valeur < 0) {
        throw ArgumentError('Valeur doit être positive');
    }
}

on vs catch

on : Capture un type spécifique

try {
    // Code
} on FormatException {
    // Seulement FormatException
} on RangeError {
    // Seulement RangeError
}

catch : Capture toutes les exceptions

try {
    // Code
} catch (e) {
    // Toutes les exceptions
    print(e);
    print(e.runtimeType);
}

catch avec stack trace :

try {
    // Code
} catch (e, stackTrace) {
    print('Erreur : $e');
    print('Stack trace : $stackTrace');
}

Lancer des exceptions

throw

Lancer une exception.

void validerAge(int age) {
    if (age < 0) {
        throw ArgumentError('Age ne peut pas être négatif');
    }
    if (age > 150) {
        throw ArgumentError('Age invalide : $age');
    }
}

rethrow

Relancer l'exception capturée.

try {
    operationRisquee();
} catch (e) {
    log('Erreur : $e');
    rethrow;  // Relance l'exception
}

Exceptions personnalisées

Créer ses propres types d'exceptions.

Classe d'exception

class ValidationException implements Exception {
    final String message;
    final String champ;
    
    ValidationException(this.message, this.champ);
    
    @override
    String toString() => '$message (champ: $champ)';
}

Utilisation

void validerEmail(String email) {
    if (email.isEmpty) {
        throw ValidationException('Email requis', 'email');
    }
    if (!email.contains('@')) {
        throw ValidationException('Email invalide', 'email');
    }
}

try {
    validerEmail('');
} on ValidationException catch (e) {
    print('Erreur de validation : ${e.message}');
    print('Champ : ${e.champ}');
}

Bonnes pratiques

1. Toujours gérer les erreurs

// ❌ Mauvais
Future<String> charger() async {
    return await http.get(url);
}

// ✅ Bon
Future<String> charger() async {
    try {
        var response = await http.get(url);
        if (response.statusCode == 200) {
            return response.body;
        } else {
            throw Exception('Erreur HTTP ${response.statusCode}');
        }
    } catch (e) {
        throw Exception('Erreur de chargement : $e');
    }
}

2. Messages d'erreur clairs

// ❌ Mauvais
throw Exception('Erreur');

// ✅ Bon
throw ValidationException('L\'email doit être valide', 'email');

3. Logging approprié

catch (e, stackTrace) {
    // Log pour développeur
    print('Erreur technique : $e');
    print('Stack trace : $stackTrace');
    
    // Message utilisateur clair
    print('Une erreur s\'est produite');
}

4. Ne pas capturer Exception générique

// ❌ Mauvais : trop général
catch (e) {
    // Cache tous les problèmes
}

// ✅ Bon : spécifique
on FormatException catch (e) {
    // Gestion spécifique
} catch (e) {
    // Gestion générale
}

Exercice

1. try/catch

   • Créez du code qui génère des exceptions
   • Capturez-les avec try/catch
   • Testez finally

2. on vs catch

   • Utilisez on pour exceptions spécifiques
   • Utilisez catch pour toutes
   • Testez stack trace

3. Exceptions personnalisées

   • Créez des exceptions personnalisées
   • Lancez-les dans votre code
   • Gérez-les spécifiquement

4. Bonnes pratiques

   • Appliquez les bonnes pratiques
   • Loggez correctement
   • Messages clairs

5. Cas pratiques

   • Créez un système de validation
   • Gèrez les erreurs de fichiers
   • Implémentez le logging

Quiz

1. Quand s'exécute finally ?

   • Seulement en cas d'erreur
   • Toujours
   • Seulement en cas de succès

2. Quelle est la différence entre on et catch ?

   • Aucune différence
   • on = type spécifique, catch = toutes
   • catch est plus rapide

3. Comment créer une exception personnalisée ?

   • throw Exception()
   • Créer une classe qui implémente Exception
   • throw "message"

4. Que fait rethrow ?

   • Supprime l'exception
   • Relance l'exception capturée
   • Crée une nouvelle exception

5. Pourquoi ne pas capturer Exception générique partout ?

   • C'est plus lent
   • Cache les problèmes spécifiques
   • C'est interdit

Mini défi

Mission : Créer un système de validation robuste

Créez un système complet de validation avec gestion d'erreurs :

Fonctionnalités :

1. Exceptions personnalisées (ValidationException, FormatException)
2. Fonctions de validation (email, age, mot de passe)
3. Gestion complète avec try/catch
4. Logging approprié
5. Messages utilisateur clairs

Critères :

• ✅ Exceptions personnalisées créées
• ✅ Toutes les validations implémentées
• ✅ Gestion d'erreurs complète
• ✅ Code robuste

Objectif : Maîtriser la gestion des erreurs Dart et créer un système robuste.

---

Validation : Vous pouvez passer au module suivant quand vous maîtrisez try/catch/finally et exceptions personnalisées.