Übung: Erstellen und Auslösen einer Ausnahme

  • 14 Minuten

Entwickler müssen häufig Ausnahmen innerhalb einer Methode erstellen und auslösen und diese Ausnahmen dann weiter unten im Aufrufstapel abfangen, wo sie behandelt werden können. Die Ausnahmebehandlung hilft Ihnen dabei, die Stabilität Ihrer Anwendungen zu gewährleisten.

In dieser Übung beginnen Sie mit einer Beispielanwendung, die eine potenzielle Fehlerbedingung in einer aufgerufenen Methode enthält. Ihre aktualisierte Methode löst (über throw) eine Ausnahme aus, wenn sie das Problem erkennt. Die Ausnahme wird in einem catch Block des Codes behandelt, der die Methode aufruft. Das Ergebnis ist eine Anwendung, die eine bessere Benutzererfahrung bietet.

Erstellen eines neuen Codeprojekts

Der erste Schritt besteht darin, ein Codeprojekt zu erstellen, das Sie während dieses Moduls verwenden können.

  1. Öffnen Sie eine neue Instanz von Visual Studio Code.

  2. Wählen Sie im Menü "Datei " die Option "Ordner öffnen" aus.

  3. Navigieren Sie im Dialogfeld "Ordner öffnen " zu Ihrem Windows-Desktopordner .

  4. Wählen Sie im Dialogfeld "Ordner öffnen " die Option "Neuer Ordner" aus.

  5. Benennen Sie den neuen Ordner ThrowExceptions101, und wählen Sie dann " Ordner auswählen" aus.

  6. Wählen Sie im Menü "Terminal " die Option "Neues Terminal" aus.

    Sie verwenden einen .NET CLI-Befehl, um eine neue Konsolen-App zu erstellen.

  7. Geben Sie an der Eingabeaufforderung des TERMINALpanels den folgenden Befehl ein:

    dotnet new console

  8. Schließen Sie das Panel TERMINAL.

Überprüfen einer Beispielanwendung

Führen Sie die folgenden Schritte aus, um eine Beispielanwendung zu laden und zu überprüfen.

  1. Öffnen Sie die Datei „Program.cs“.

  2. Wählen Sie im Menü "Ansicht" die Befehlspalette aus.

  3. Geben Sie an der Eingabeaufforderung .net: g ein, und wählen Sie dann .NET: Ressourcen für Build und Debug generieren.

  4. Ersetzen Sie den Inhalt der Datei Program.cs durch den folgenden Code:

    // 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. Überprüfen Sie kurz den Code.

    Beachten Sie, dass die Anwendung die folgenden Aufgaben ausführt:

    1. Die Anweisungen auf oberster Ebene verwenden Console.ReadLine() Anweisungen zum Abrufen von Werten für lowerBound und upperBound.

    2. Die Anweisungen der obersten Ebene übergeben lowerBound und upperBound als Argumente beim Aufrufen der AverageOfEvenNumbers Methode.

    3. Die AverageOfEvenNumbers Methode führt die folgenden Aufgaben aus:

      1. Deklariert lokale Variablen, die in Berechnungen verwendet werden.
      2. Verwendet eine for-Schleife, um die geraden Zahlen zwischen lowerBound und upperBound zu summieren. Die Summe wird gespeichert in sum.
      3. Zählt, wie viele Zahlen in die Summe einbezogen werden. Die Anzahl wird in count gespeichert.
      4. Speichert den Mittelwert der summierten Zahlen in einer Variablen mit dem Namen average. Der Wert von average wird zurückgegeben.

    4. Die Anweisungen der obersten Ebene drucken den Wert, der von AverageOfEvenNumbers zur Konsole zurückgegeben wird, und halten dann die Ausführung an.

Konfigurieren der Debugumgebung

Die Beispielanwendung liest Benutzereingaben aus der Konsole vor. Der DEBUG CONSOLE-Bereich unterstützt das Lesen von Eingaben über die Konsole nicht. Sie müssen die launch.json Datei aktualisieren, bevor Sie diese Anwendung im Debugger ausführen können.

  1. Verwenden Sie die EXPLORER-Ansicht, um die Datei „launch.json“ zu öffnen.

  2. Aktualisieren Sie in der Datei „launch.json“ das Attribut console wie folgt:

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

    Der Standardwert für das console-Attribut lautet internalConsole und ist damit auf das Panel DEBUGGING-KONSOLE ausgerichtet. Leider unterstützt der DEBUG CONSOLE-Bereich keine Konsoleneingaben. Die integratedTerminal-Einstellung entspricht dem Panel „Terminal“, das Konsoleneingaben und -ausgaben unterstützt.

  3. Speichern Sie Ihre Änderungen in der launch.json Datei, und schließen Sie die Datei.

  4. Wählen Sie im Menü " Visual Studio Code Ausführen" die Option "Debuggen starten" aus.

  5. Wechseln Sie zum Bereich TERMINAL.

  6. Geben Sie an der Eingabeaufforderung "Untergrenze" 3 ein.

  7. Geben Sie an der Eingabeaufforderung "obere Grenze" 11 ein.

  8. Beachten Sie, dass die Anwendung die folgende Meldung anzeigt und dann angehalten wird:

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

  9. Drücken Sie die EINGABETASTE, um die Anwendung zu beenden.

Auslösen einer Ausnahme in der AverageOfEvenNumbers-Methode

Die AverageOfEvenNumbers Methode erwartet eine obere Grenze, die größer als die untere Grenze ist. Wenn die untere Grenze größer oder gleich der oberen Grenze ist, tritt ein DivideByZero Fehler auf.

Sie müssen die AverageOfEvenNumbers Methode aktualisieren, um eine Ausnahme auszuwerfen, wenn die untere Grenze größer oder gleich der oberen Grenze ist.

  1. Nehmen Sie sich eine Minute Zeit, um zu überlegen, wie Sie das Problem beheben möchten.

    Eine Option besteht darin, die Berechnung von average mit einem try-Codeblock zu umschließen und die catch-Ausnahme bei ihrem Auftreten über DivideByZero abzufangen. Sie können die Ausnahme erneut auslösen und anschließend im aufrufenden Code behandeln.

    Eine weitere Option besteht darin, die Eingabeparameter vor dem Starten der Berechnungen auszuwerten. Wenn lowerBound größer oder gleich upperBoundist, können Sie eine Ausnahme auslösen.

    Die Auswertung der Parameter und das Auslösen einer Ausnahme vor dem Starten der Berechnungen ist die bessere Wahl.

  2. Überlegen Sie, welcher Ausnahmetyp ausgelöst werden soll.

    Es gibt zwei Ausnahmetypen, die mit dem Problem übereinstimmen:

    • ArgumentOutOfRangeException - Ein ArgumentOutOfRangeException Ausnahmetyp sollte nur ausgelöst werden, wenn sich der Wert eines Arguments außerhalb des zulässigen Wertebereichs befindet, wie durch die aufgerufene Methode definiert. Obwohl AverageOfEvenNumbers ein zulässiger Bereich nicht explizit für lowerBound oder upperBounddefiniert wird, impliziert der Wert lowerBound den zulässigen Bereich für upperBound.
    • InvalidOperationException: Ein InvalidOperationException Ausnahmetyp sollte nur ausgelöst werden, wenn die Betriebsbedingungen einer Methode den erfolgreichen Abschluss eines bestimmten Methodenaufrufs nicht unterstützen. In diesem Fall werden die Betriebsbedingungen durch die Eingabeparameter der Methode festgelegt.

    Wenn Sie zwei oder mehr Ausnahmetypen auswählen möchten, wählen Sie den Ausnahmetyp aus, der dem Problem näher entspricht. In diesem Fall sind die beiden Ausnahmetypen im gleichen Maße auf das Problem abgestimmt.

    Wenn Sie zwei oder mehr Ausnahmetypen haben, die auf das Problem gleichermaßen ausgerichtet sind, wählen Sie den am engsten begrenzten Ausnahmetyp aus. Der ArgumentOutOfRangeException Ausnahmetyp ist auf die Argumente zugeschnitten, die an die Methode übergeben werden. Der InvalidOperationException Ausnahmetyp ist auf die Betriebsbedingungen der Methode abgegrenzt. In diesem Fall ist der ArgumentOutOfRangeException Ausnahmetyp enger gefasst als der InvalidOperationException Ausnahmetyp.

    Die AverageOfEvenNumbers Methode sollte eine ArgumentOutOfRangeException Ausnahme auslösen.

  3. Aktualisieren Sie den Code am Anfang der AverageOfEvenNumbers-Methode wie folgt, um das Problem der oberen Grenze zu erkennen:

    if (lowerBound >= upperBound)
{

}

int sum = 0;

  4. Um eine ArgumentOutOfRangeException Ausnahme zu erstellen und auszuwerfen, aktualisieren Sie den if Codeblock wie folgt:

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

    Diese Codezeile initialisiert eine neue Instanz der ArgumentOutOfRangeException Klasse mit dem Namen des Eingabeparameters, der die Ausnahme und eine angegebene Fehlermeldung verursacht.

Abfangen der Ausnahme im aufrufenden Code

Ausnahmen sollten nach Möglichkeit auf einer Ebene innerhalb der Aufrufliste abgefangen werden, auf der sie behandelt werden können. In dieser Beispielanwendung können die Parameter der AverageOfEvenNumbers Methode in der aufrufenden Methode (die Anweisungen der obersten Ebene) verwaltet werden.

  1. Scrollen Sie nach oben zu den Anweisungen der obersten Ebene.

  2. Um den AverageOfEvenNumbers Methodenaufruf und die Console.WriteLine Anweisung in einen try Codeblock einzuschließen, aktualisieren Sie Ihren Code wie folgt:

    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. Geben Sie den folgenden Code ein, um die zugeordnete catch Klausel zu erstellen:

    catch(ArgumentOutOfRangeException ex)
{

}

  4. Nehmen Sie sich eine Minute Zeit, um zu überlegen, wie Sie die Ausnahme behandeln können.

    Um diese Ausnahme zu behandeln, muss Ihr Code die folgenden Schritte ausführen:

    • Erläutern Sie das Problem für den Benutzer.
    • Abrufen eines neuen Werts für upperBound.
    • Aufrufen von AverageOfEvenNumbers mit dem neuen upperBound-Wert.
    • Erneutes Abfangen der Ausnahme (über catch), wenn der neu bereitgestellte upperBound-Wert immer noch kleiner oder gleich lowerBound ist.

    Das fortgesetzte Abfangen der Ausnahme (über catch) erfordert eine Schleife. Da Sie die AverageOfEvenNumbers Methode mindestens einmal aufrufen möchten, sollte eine do Schleife verwendet werden.

  5. Um die Blöcke try und catch in eine do Schleife einzuschließen, aktualisieren Sie Ihren Code wie folgt:

    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)
    {

    }
}

    Ein while Ausdruck ist erforderlich, um die Beendigungsbedingung einer do Schleife zu definieren. Es ist schwierig, die Bedingung anzugeben, bevor der Inhalt des do Codeblocks definiert wird. Wenn Sie den catch Codeblock abschließen, können Sie den while benötigten Ausdruck definieren.

  6. Um das Problem für den Benutzer zu erläutern und einen neuen upperBoundzu erhalten, aktualisieren Sie den catch Codeblock wie folgt:

    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());
}

    Der aktualisierte catch Codeblock beschreibt das Problem und erfordert, dass der Benutzer eine neue obere Grenze eingibt. Was geschieht jedoch, wenn der Benutzer keinen gültigen oberen Grenzwert eingeben kann? Was geschieht, wenn der Benutzer die Schleife beenden muss, anstatt einen Wert einzugeben?

  7. Um dem Benutzer eine Option zum Beenden der Schleife zu ermöglichen, anstatt eine neue obere Grenze einzugeben, aktualisieren Sie den catch Codeblock wie folgt:

    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);
    }
}

    Der aktualisierte Codeblock catch enthält zwei Pfade, einen Pfad für die Beendigung und einen Pfad für eine neue Obergrenze.

  8. Nehmen Sie sich einen Moment Zeit, um den für die while-Schleife benötigten do-Ausdruck zu betrachten.

    Wenn der Benutzer an der Eingabeaufforderung "Exit" eingibt, sollte der Code die Schleife beenden. Wenn der Benutzer eine neue obere Grenze eingibt, sollte die Schleife fortgesetzt werden. Ein while Ausdruck, der einen booleschen Ausdruck auswertet, kann verwendet werden. Beispiel:

    while (exit == false);

    Der vorgeschlagene while Ausdruck legt das folgende Verhalten fest:

    • Die do-Schleife wird so lange durchlaufen, bis der boolesche Wert exit als false ausgewertet wird.
    • die do Schleife beendet das Iterieren, sobald der boolesche exit Wert gleich trueist.

  9. Um eine boolesche Variable namens exit zu instanziieren und exit zur Festlegung der Beendigungsbedingung der do-Schleife zu verwenden, aktualisieren Sie Ihren Code wie folgt:

    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. Speichern Sie den aktualisierten Code.

  11. Wählen Sie im Menü "Ausführen " die Option "Debuggen starten" aus.

  12. Wechseln Sie zum Bereich TERMINAL.

  13. Geben Sie an der Eingabeaufforderung "Untergrenze" 3 ein.

  14. Geben Sie an der Eingabeaufforderung "obere Grenze" 3 ein.

  15. Beachten Sie, dass die folgende Ausgabe im TERMINAL-Bereich angezeigt wird:

    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. Geben Sie an der Eingabeaufforderung für eine neue obere Grenze 11 ein.

  17. Beachten Sie, dass die folgende Ausgabe im TERMINAL-Bereich angezeigt wird:

    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. Drücken Sie die EINGABETASTE, um die Anwendung zu beenden.

Glückwunsch! Sie haben erfolgreich eine Ausnahme ausgelöst, abgefangen und behandelt.

Zusammenfassung

Nachstehend finden Sie nochmals die wichtigsten Punkte aus dieser Lerneinheit:

  • Stellen Sie sicher, dass Ihre Debugumgebung für die Unterstützung Ihrer Anwendungsanforderungen konfiguriert ist.
  • Der Methodencode sollte eine Ausnahme auslösen, wenn ein Problem oder eine Bedingung erkannt wird.
  • Ausnahmen sollten auf einer Ebene im Aufrufstapel erfasst werden, in der sie aufgelöst werden können.