Exercice - Implémenter la gestion des exceptions try-catch

9 minutes

Le try-catch modèle se compose d’un try bloc suivi d’une ou plusieurs catch clauses. Chaque catch clause spécifie le gestionnaire pour un type d’exception différent.

Lorsqu’une exception est levée, le Common Language Runtime (CLR) recherche une catch clause qui peut gérer l’exception. Si la méthode en cours d’exécution ne contient pas de clause qui peut gérer le type d’exception catch levée, le CLR recherche la méthode qui a appelé la méthode actuelle. La recherche se poursuit dans la pile des appels jusqu’à ce qu’une clause appropriée catch soit trouvée. Si aucune clause n’est catch trouvée pour gérer l’exception, le CLR affiche un message d’exception non géré à l’utilisateur et arrête l’exécution du programme.

Dans cet exercice, vous allez implémenter un modèle de base try-catch .

Créer un projet de code

Votre première étape consiste à créer un projet de code que vous utilisez pendant ce module.

Ouvrez une nouvelle instance de Visual Studio Code.
Dans le menu Fichier , sélectionnez Ouvrir le dossier.
Dans la boîte de dialogue Ouvrir le dossier , accédez à votre dossier Windows Desktop .
Dans la boîte de dialogue Ouvrir le dossier , sélectionnez Nouveau dossier.
Nommez le nouveau dossier Exceptions101, puis sélectionnez Sélectionner un dossier.
Dans le menu Terminal , sélectionnez Nouveau terminal.

Vous utiliserez une commande CLI .NET pour créer une application console.
À l’invite de commandes du panneau TERMINAL, entrez les commandes suivantes :
```
dotnet new console
```
Fermez le panneau TERMINAL.

Implémenter un try-catch simple

Utilisez la vue Explorateur visual Studio Code pour ouvrir le fichier Program.cs.
Dans le menu Affichage, sélectionnez Palette de commandes.
Dans l’invite de commandes, entrez .net: g, puis sélectionnez .NET : Générer des ressources pour le développement et le débogage.

Remplacez le contenu du fichier Program.cs par le code suivant :

double float1 = 3000.0;
double float2 = 0.0;
int number1 = 3000;
int number2 = 0;

Console.WriteLine(float1 / float2);
Console.WriteLine(number1 / number2);
Console.WriteLine("Exit program");

Prenez le temps d’examiner le code.

Notez que l’application utilise deux types de variables numériques et doubleint. Le code effectue un calcul de division à l’aide des deux types numériques.

Les développeurs utilisent une double variable de type pour les calculs lorsque des valeurs fractionnelles précises sont importantes.
Dans le menu Exécuter , sélectionnez Démarrer le débogage.

Notez qu’une DivideByZeroException exception se produit lors de la division des valeurs entières.

Remarque

Vous avez peut-être remarqué que l’équation utilisant des variables de type double est en mesure de se terminer sans provoquer d’erreur. Un calcul de division par zéro à l’aide double de variables de type retourne un résultat égal à l’infini, -infini ou « pas un nombre ». Cela ne signifie pas que vous devez toujours utiliser les variables de type double au lieu de type int ou decimal. L’approche correcte consiste à utiliser des variables du type approprié et à implémenter la gestion des exceptions pour intercepter les erreurs susceptibles de se produire.
Dans la barre d’outils Déboguer, sélectionnez Continuer.
Prenez une minute pour examiner la sortie des messages de votre application.
```
∞
Unhandled exception. System.DivideByZeroException: Attempted to divide by zero.
   at Program.<Main>$(String[] args) in C:\Users\msuser\Desktop\Exceptions101\Program.cs:line 7
```
Notez que l’exception non gérée a provoqué l’arrêt de votre application une fois la première Console.WriteLine() instruction terminée.

Remarque

Par défaut, Visual Studio Code utilise un texte de couleur différent pour afficher les messages générés par le débogueur. Cela permet au développeur de différencier la sortie de l’application et les messages du débogueur. Si vous souhaitez une vue plus claire de la sortie de votre application, vous pouvez configurer le fichier launch.json pour utiliser une autre console. Par exemple, définissez console sur integratedTerminal pour utiliser le panneau TERMINAL pour la sortie de l'application. Les messages du débogueur sont toujours affichés dans le panneau CONSOLE DEBUG.

Placez les deux calculs dans le bloc de code d’une try instruction comme suit :

double float1 = 3000.0;
double float2 = 0.0;
int number1 = 3000;
int number2 = 0;

try
{
    Console.WriteLine(float1 / float2);
    Console.WriteLine(number1 / number2);
}

Console.WriteLine("Exit program");

Notez la ligne rouge ondulée sous le crochet fermant du bloc try.

La syntaxe C# nécessite une clause catch ou finally lorsque vous utilisez une instruction try.

Construisez un catch bloc de code sous le bloc de try code comme suit :

try
{
    Console.WriteLine(float1 / float2);
    Console.WriteLine(number1 / number2);
}
catch
{
    Console.WriteLine("An exception has been caught");
}

Dans le menu Fichier Visual Studio Code, sélectionnez Enregistrer.
Dans le menu Exécuter , sélectionnez Démarrer le débogage.
Prenez une minute pour examiner la sortie produite par votre application.
```
∞
An exception has been caught
Exit program
```
Notez que même si l’exception se produit toujours, votre application est maintenant en mesure de terminer l’exécution des lignes de code restantes avant la fermeture.

La gestion des exceptions vous permet de contrôler l’exécution du code lorsque des exceptions se produisent. La gestion des exceptions permet de s’assurer que votre code est stable et produit les résultats attendus.

Intercepter les exceptions levées dans les méthodes appelées

Dans de nombreux cas, une exception est interceptée à un niveau de la pile des appels inférieur au niveau où elle a été levée.

Lorsqu’une exception est levée et que la méthode actuelle n’intercepte pas l’exception, le Common Language Runtime décompresse la pile, recherchant une méthode qui contient une catch clause qui peut gérer l’exception. La première catch clause trouvée qui peut gérer l’exception est exécutée. Si aucune clause appropriée catch n’est trouvée n’importe où dans la pile des appels, le Common Language Runtime met fin au processus et affiche un message d’erreur à l’utilisateur.

Remplacez le code dans votre fichier Program.cs par le code suivant :

try
{
    Process1();
}
catch
{
    Console.WriteLine("An exception has occurred");
}

Console.WriteLine("Exit program");

static void Process1()
{
    WriteMessage();
}

static void WriteMessage()
{
    double float1 = 3000.0;
    double float2 = 0.0;
    int number1 = 3000;
    int number2 = 0;

    Console.WriteLine(float1 / float2);
    Console.WriteLine(number1 / number2);
}

Prenez une minute pour passer en revue le code mis à jour.
- Les instructions de niveau supérieur incluent le try bloc de code qui appelle la Process1() méthode.
- La Process1() méthode appelle la WriteMessage() méthode.
- La WriteMessage() méthode contient le code dans lequel l’exception DivideByZeroException sera levée.
Notez que l’exception sera générée dans une méthode qui se trouve à deux niveaux de pile d'appels au-dessus des blocs de code try et catch.

Les instructions de niveau supérieur sont représentées sous la forme d’une méthode nommée Main dans la pile des appels.
Dans le menu Fichier Visual Studio Code, sélectionnez Enregistrer.
Dans le menu Exécuter , sélectionnez Démarrer le débogage.
Prenez une minute pour examiner la sortie produite par votre application.
```
∞
An exception has occurred
Exit program
```
Notez que même si l’exception est levée deux niveaux plus haut dans la pile des appels, elle est toujours gérée avec succès.

Récapitulatif

Voici quelques points importants à retenir de cette unité :

Implémentez un modèle try-catch pour les lignes de code try spécifiées dans votre application et les exceptions catch qui se produisent dans l’étendue du bloc de code try.
Utilisez une catch clause pour intercepter une exception levée au même niveau de la pile des appels.
Utilisez une clause catch pour intercepter une exception levée à un niveau supérieur de la pile des appels.

Commentaires

Cette page a-t-elle été utile ?