Exercice - Créer et lever une exception

  • 14 minutes

Les développeurs doivent souvent créer et lever des exceptions à partir d’une méthode, puis intercepter ces exceptions plus loin dans la pile des appels où elles peuvent être gérées. La gestion des exceptions vous permet de garantir la stabilité de vos applications.

Dans cet exercice, vous allez commencer par un exemple d’application qui inclut une condition d’erreur potentielle à l’intérieur d’une méthode appelée. Votre méthode mise à jour lancera throw une exception lorsqu’elle détecte le problème. L’exception est gérée dans un catch bloc du code qui appelle la méthode. Le résultat est une application qui offre une meilleure expérience utilisateur.

Créer un projet de code

La première étape consiste à créer un projet de code que vous pouvez utiliser pendant ce module.

  1. Ouvrez une nouvelle instance de Visual Studio Code.

  2. Dans le menu Fichier, sélectionnez Ouvrir le dossier.

  3. Dans la boîte de dialogue Ouvrir le dossier , accédez à votre dossier Windows Desktop .

  4. Dans la boîte de dialogue Ouvrir le dossier , sélectionnez Nouveau dossier.

  5. Nommez le nouveau dossier ThrowExceptions101, puis sélectionnez Sélectionner un dossier.

  6. Dans le menu Terminal, sélectionnez Nouveau terminal.

    Vous utiliserez une commande CLI .NET pour créer une application console.

  7. À l’invite de commandes du panneau TERMINAL, entrez la commande suivante :

    dotnet new console

  8. Fermez le panneau TERMINAL.

Passer en revue un exemple d’application

Procédez comme suit pour charger et examiner un exemple d’application.

  1. Ouvrez le fichier Program.cs.

  2. Dans le menu Affichage, sélectionnez Palette de commandes.

  3. À l’invite de commandes, entrez .net: g et sélectionnez .NET : Générer des ressources pour Build et Debug.

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

    // Prompt the user for the lower and upper bounds
Console.Write("Enter the lower bound: ");
int lowerBound = int.Parse(Console.ReadLine());

Console.Write("Enter the upper bound: ");
int upperBound = int.Parse(Console.ReadLine());

decimal averageValue = 0;

// Calculate the sum of the even numbers between the bounds
averageValue = AverageOfEvenNumbers(lowerBound, upperBound);

// Display the value returned by AverageOfEvenNumbers in the console
Console.WriteLine($"The average of even numbers between {lowerBound} and {upperBound} is {averageValue}.");

// Wait for user input
Console.ReadLine();

static decimal AverageOfEvenNumbers(int lowerBound, int upperBound)
{
    int sum = 0;
    int count = 0;
    decimal average = 0;

    for (int i = lowerBound; i <= upperBound; i++)
    {
        if (i % 2 == 0)
        {
            sum += i;
            count++;
        }
    }

    average = (decimal)sum / count;

    return average;
}

  5. Prenez le temps de passer le code en revue.

    Notez que l’application effectue les tâches suivantes :

    1. Les instructions de niveau supérieur utilisent des instructions Console.ReadLine() pour obtenir des valeurs pour lowerBound et upperBound.

    2. Les instructions de niveau supérieur passent lowerBound et upperBound en tant qu’arguments lors de l’appel de la AverageOfEvenNumbers méthode.

    3. La AverageOfEvenNumbers méthode effectue les tâches suivantes :

      1. Déclare les variables locales utilisées dans les calculs.
      2. Utilise une for boucle pour additionner les nombres pairs entre lowerBound et upperBound. La somme est stockée dans sum.
      3. Compte le nombre de nombres inclus dans la somme. Le nombre est stocké dans count.
      4. Stocke la moyenne des nombres additionnés dans une variable nommée average. La valeur de average est retournée.

    4. Les instructions de niveau supérieur affichent sur la console la valeur retournée par AverageOfEvenNumbers, puis suspendent l'exécution.

Configurez l’environnement de débogage

L’exemple d’application lit l’entrée utilisateur à partir de la console. Le panneau CONSOLE DE DÉBOGAGE ne prend pas en charge la lecture d’entrées à partir de la console. Vous devez mettre à jour le fichier launch.json avant de pouvoir exécuter cette application dans le débogueur.

  1. Utilisez la vue EXPLORATEUR pour ouvrir le fichier launch.json.

  2. Dans le fichier launch.json, mettez à jour l’attribut console comme suit :

    // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
"console":"integratedTerminal",

    La valeur par défaut de l’attribut console est internalConsole, qui s’aligne sur le panneau CONSOLE DE DÉBOGAGE. Malheureusement, le panneau CONSOLE DEBUG ne prend pas en charge l’entrée de la console. Le paramètre integratedTerminal s’aligne sur le panneau TERMINAL, qui prend en charge l’entrée et la sortie de la console.

  3. Enregistrez vos modifications dans le fichier launch.json, puis fermez le fichier.

  4. Dans le menu Exécuter de Visual Studio Code, sélectionnez Lancer le débogage.

  5. Basculez sur le panneau TERMINAL.

  6. À l’invite « limite inférieure », entrez 3

  7. À l’invite « limite supérieure », entrez 11

  8. Notez que l’application affiche le message suivant, puis s’interrompt :

    The average of even numbers between 3 and 11 is 7.

  9. Pour quitter l’application, appuyez sur Entrée.

Lever une exception dans la méthode AverageOfEvenNumbers

La AverageOfEvenNumbers méthode attend une limite supérieure qui est plus grande que la limite inférieure. Une DivideByZero erreur se produit si la limite inférieure est supérieure ou égale à la limite supérieure.

Vous devez mettre à jour la AverageOfEvenNumbers méthode pour lever une exception lorsque la limite inférieure est supérieure ou égale à la limite supérieure.

  1. Prenez une minute pour prendre en compte la façon dont vous souhaitez résoudre le problème.

    Une option consiste à envelopper le calcul de average dans un bloc de code try et à effectuer un catch de l’exception DivideByZero lorsqu’elle se produit. Vous pouvez relancer l’exception, puis la gérer dans le code appelant.

    Une autre option consiste à évaluer les paramètres d’entrée avant de démarrer les calculs. Si lowerBound est supérieur ou égal à upperBound, vous pouvez déclencher une exception.

    L’évaluation des paramètres et la levée d’une exception avant de commencer les calculs est le meilleur choix.

  2. Déterminez le type d’exception à lever.

    Il existe deux types d’exceptions qui s’alignent sur le problème :

    • ArgumentOutOfRangeException - Un type d’exception ArgumentOutOfRangeException ne doit être levée que lorsque la valeur d’un argument se trouve en dehors de la plage autorisée de valeurs telle que définie par la méthode appelée. Bien que AverageOfEvenNumbers ne définisse pas explicitement une plage autorisée pour lowerBound ou upperBound, la valeur de lowerBound implique la plage autorisée pour upperBound.
    • InvalidOperationException: un type d’exception InvalidOperationException ne doit être levée que lorsque les conditions d’exploitation d’une méthode ne prennent pas en charge la réussite d’un appel de méthode particulier. Dans ce cas, les conditions d’exploitation sont établies par les paramètres d’entrée de la méthode.

    Lorsque vous avez deux types d’exceptions ou plus à choisir, sélectionnez le type d’exception qui correspond au problème de façon plus étroite. Dans ce cas, les deux types d’exceptions sont alignés sur le problème de façon égale.

    Lorsque vous avez deux types d’exceptions ou plus alignés sur le problème de façon égale, sélectionnez le type d’exception le plus étroitement délimité. Le ArgumentOutOfRangeException type d’exception est limité aux arguments passés à la méthode. Le InvalidOperationException type d’exception est limité aux conditions d’exploitation de la méthode. Dans ce cas, le ArgumentOutOfRangeException type d’exception est plus limité que le type d’exception InvalidOperationException .

    La AverageOfEvenNumbers méthode doit lever une ArgumentOutOfRangeException exception.

  3. Au début de la méthode AverageOfEvenNumbers, pour détecter le problème de limite supérieure, mettez à jour votre code comme suit :

    if (lowerBound >= upperBound)
{

}

int sum = 0;

  4. Pour créer et lever une ArgumentOutOfRangeException exception, mettez à jour le bloc de if code comme suit :

    if (lowerBound >= upperBound)
{
    throw new ArgumentOutOfRangeException("upperBound", "ArgumentOutOfRangeException: upper bound must be greater than lower bound.");
}

    Cette ligne de code initialise une nouvelle instance de la ArgumentOutOfRangeException classe avec le nom du paramètre d’entrée qui provoque l’exception et un message d’erreur spécifié.

Intercepter l’exception dans le code appelant

Dans la mesure du possible, les exceptions doivent être interceptées au niveau de la pile des appels où elles peuvent être gérées. Dans cet exemple d’application, les paramètres de la AverageOfEvenNumbers méthode peuvent être gérés dans la méthode appelante (instructions de niveau supérieur).

  1. Faites défiler vers le haut jusqu’aux déclarations de niveau supérieur.

  2. Pour placer l’appel de méthode AverageOfEvenNumbers et l’instruction Console.WriteLine à l’intérieur d’un bloc de code try, mettez à jour votre code comme suit :

    try
{
    // Calculate the sum of the even numbers between the bounds
    averageValue = AverageOfEvenNumbers(lowerBound, upperBound);

    // Display the result to the user
    Console.WriteLine($"The average of even numbers between {lowerBound} and {upperBound} is {averageValue}.");
}

  3. Pour créer la clause associée catch , entrez le code suivant :

    catch(ArgumentOutOfRangeException ex)
{

}

  4. Prenez une minute pour prendre en compte la façon dont vous pouvez gérer l’exception.

    Pour gérer cette exception, votre code doit effectuer les opérations suivantes :

    • Expliquer le problème à l’utilisateur.
    • Obtenez une nouvelle valeur pour upperBound.
    • Appelez AverageOfEvenNumbers en utilisant le nouveau upperBound.
    • Passez à l’exception catch si le nouveau upperBound fourni est toujours inférieur ou égal à lowerBound.

    Le fait de continuer à effectuer un catch sur l’exception nécessite une boucle. Étant donné que vous souhaitez appeler la AverageOfEvenNumbers méthode au moins une fois, une do boucle doit être utilisée.

  5. Pour placer les blocs try et catch à l'intérieur d'une boucle do, mettez à jour votre code comme suit :

    do
{
    try
    {
        // Calculate the sum of the even numbers between the bounds
        averageValue = AverageOfEvenNumbers(lowerBound, upperBound);

        // Display the result to the user
        Console.WriteLine($"The average of even numbers between {lowerBound} and {upperBound} is {averageValue}.");
    }
    catch (ArgumentOutOfRangeException ex)
    {

    }
}

    Une while expression est requise pour définir la condition de sortie d’une do boucle. Il est difficile de spécifier la condition avant la définition du contenu du bloc de do code. Finir le bloc de code catch vous aidera à définir l’expression while nécessaire.

  6. Pour expliquer le problème à l'utilisateur et obtenir un nouveau upperBound, mettez à jour votre bloc de code catch comme suit :

    catch (ArgumentOutOfRangeException ex)
{
    Console.WriteLine("An error has occurred.");
    Console.WriteLine(ex.Message);
    Console.WriteLine($"The upper bound must be greater than {lowerBound}");
    Console.Write($"Enter a new upper bound: ");
    upperBound = int.Parse(Console.ReadLine());
}

    Le bloc de code mis à jour catch décrit le problème et exige que l’utilisateur entre une nouvelle limite supérieure. Toutefois, que se passe-t-il si l’utilisateur n’a pas de valeur limite supérieure valide à entrer ? Que se passe-t-il si l’utilisateur doit quitter la boucle plutôt que d’entrer une valeur ?

  7. Pour permettre à l’utilisateur de quitter la boucle plutôt que d’entrer une nouvelle limite supérieure, mettez à jour votre catch bloc de code comme suit :

    catch (ArgumentOutOfRangeException ex)
{
    Console.WriteLine("An error has occurred.");
    Console.WriteLine(ex.Message);
    Console.WriteLine($"The upper bound must be greater than {lowerBound}");
    Console.Write($"Enter a new upper bound (or enter Exit to quit): ");
    string? userResponse = Console.ReadLine();
    if (userResponse.ToLower().Contains("exit"))
    {

    }
    else
    {
        upperBound = int.Parse(userResponse);
    }
}

    Le bloc de code mis à jour catch comprend deux chemins, un chemin « sortie » et un chemin « nouvelle limite supérieure ».

  8. Prenez une minute pour prendre en compte l’expression while requise pour la do boucle.

    Si l’utilisateur entre « Exit » à l’invite, le code doit quitter la boucle. Si l’utilisateur entre une nouvelle limite supérieure, la boucle doit continuer. Expression while qui évalue une valeur booléenne peut être utilisée. Par exemple:

    while (exit == false);

    L’expression proposée while établit le comportement suivant :

    • la do boucle continue d’itérer tant que la valeur booléenne exit est égale à false.
    • la do boucle arrête l’itération dès que la valeur booléenne exit est égale à true.

  9. Pour instancier une variable booléenne nommée exitet utiliser exit pour définir la condition de sortie de la do boucle, mettez à jour votre code comme suit :

    bool exit = false;

do
{
    try
    {
        // Calculate the sum of the even numbers between the bounds
        averageValue = AverageOfEvenNumbers(lowerBound, upperBound);

        // Display the result to the user
        Console.WriteLine($"The average of even numbers between {lowerBound} and {upperBound} is {averageValue}.");

        exit = true;
    }
    catch (ArgumentOutOfRangeException ex)
    {
        Console.WriteLine("An error has occurred.");
        Console.WriteLine(ex.Message);
        Console.WriteLine($"The upper bound must be greater than {lowerBound}");
        Console.Write($"Enter a new upper bound (or enter Exit to quit): ");
        string? userResponse = Console.ReadLine();
        if (userResponse.ToLower().Contains("exit"))
        {
            exit = true;
        }
        else
        {
            exit = false;
            upperBound = int.Parse(userResponse);
        }
    }    
} while (exit == false);

  10. Enregistrez votre code mis à jour.

  11. Dans le menu Exécuter, sélectionnez Démarrer le débogage.

  12. Basculez sur le panneau TERMINAL.

  13. À l’invite « limite inférieure », entrez 3

  14. À l’invite « limite supérieure », entrez 3

  15. Notez que la sortie suivante s’affiche dans le panneau TERMINAL :

    Enter the lower bound: 3
Enter the upper bound: 3
An error has occurred.
ArgumentOutOfRangeException: upper bound must be greater than lower bound. (Parameter 'upperBound')
The upper bound must be greater than 3
Enter a new upper bound (or enter Exit to quit):

  16. À l'invite de saisie d'une nouvelle limite supérieure, entrez 11

  17. Notez que la sortie suivante s’affiche dans le panneau TERMINAL :

    Enter the lower bound: 3
Enter the upper bound: 3
An error has occurred.
ArgumentOutOfRangeException: upper bound must be greater than lower bound. (Parameter 'upperBound')
The upper bound must be greater than 3
Enter a new upper bound (or enter Exit to quit): 11
The average of even numbers between 3 and 11 is 7.

  18. Pour quitter l’application, appuyez sur Entrée.

Félicitations! Vous avez réussi à lever, intercepter et gérer une exception.

Récapitulatif

Voici quelques points importants à retenir de cette unité :

  • Vérifiez que votre environnement de débogage est configuré pour prendre en charge les exigences de votre application.
  • Le code de méthode doit lever une exception lorsqu’un problème ou une condition est détecté.
  • Les exceptions doivent être interceptées à un niveau de la pile des appels où elles peuvent être résolues.