Oefening: de verwerking van try-catch-uitzonderingen implementeren

9 minuten

Het try-catch patroon bestaat uit een try blok gevolgd door een of meer catch componenten. Elke catch component specificeert de handler voor een ander uitzonderingstype.

Wanneer er een uitzondering wordt gegenereerd, zoekt de Common Language Runtime (CLR) naar een catch component die de uitzondering kan verwerken. Als de momenteel uitgevoerde methode geen catch clausule bevat dat kan omgaan met het gegenereerde uitzonderingstype, zoekt de CLR naar de methode die de huidige methode heeft aangeroepen. De zoekopdracht gaat verder door de aanroepstack totdat er een geschikte catch clausule wordt gevonden. Als er geen catch component wordt gevonden om de uitzondering af te handelen, geeft de CLR een niet-verwerkte uitzonderingsbericht weer aan de gebruiker en stopt de uitvoering van het programma.

In deze oefening implementeert u een basispatroon try-catch .

Een nieuw codeproject maken

De eerste stap is het maken van een codeproject dat u tijdens deze module gebruikt.

Open een nieuw exemplaar van Visual Studio Code.
In het menu File, selecteer Map openen.
Navigeer in het Open Folder dialoogvenster naar uw Windows Desktop map.
Selecteer in het dialoogvenster Map openen de optie Nieuwe map.
Noem de nieuwe map Exceptions101 en selecteer Selecteer map.
Selecteer Nieuwe terminal in het menu Terminal.

U gebruikt een .NET CLI-opdracht om een nieuwe console-app te maken.
Voer bij de opdrachtprompt van het TERMINAL-deelvenster de volgende opdrachten in:
```
dotnet new console
```
Sluit het TERMINAL-deelvenster.

Een eenvoudige try-catch implementeren

Gebruik de visual Studio Code EXPLORER-weergave om het bestand Program.cs te openen.
Selecteer Opdrachtpalet in het menu Beeld.
Voer bij de opdrachtprompt .net in: g en selecteer vervolgens .NET: Assets genereren voor build en foutopsporing.

Vervang de inhoud van het bestand Program.cs door de volgende code:

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

Neem even de tijd om de code te bekijken.

U ziet dat de toepassing gebruikmaakt van twee typen numerieke variabelen en doubleint. De code voert een verdelingsberekening uit met behulp van beide numerieke typen.

Ontwikkelaars gebruiken een double typevariabele voor berekeningen wanneer nauwkeurige breukwaarden belangrijk zijn.
Selecteer in het menu Uitvoeren de foutopsporing starten.

U ziet dat er een DivideByZeroException uitzondering optreedt bij het delen van de gehele getallen.

Opmerking

Mogelijk hebt u gemerkt dat de vergelijking met behulp van variabelen van het type double kan worden voltooid zonder dat er een fout optreedt. Een berekening van deling per nul met behulp van double typevariabelen retourneert een resultaat dat gelijk is aan oneindigheid, -oneindig of 'geen getal'. Dit betekent niet dat u altijd double-type variabelen moet gebruiken in plaats van int-typen of decimal-typen. De juiste aanpak is het gebruik van variabelen van het juiste type en het implementeren van uitzonderingsafhandeling om eventuele fouten te ondervangen.
Op de Debug werkbalk selecteer Doorgaan.
Neem even de tijd om de berichtuitvoer voor uw toepassing te bekijken.
```
∞
Unhandled exception. System.DivideByZeroException: Attempted to divide by zero.
   at Program.<Main>$(String[] args) in C:\Users\msuser\Desktop\Exceptions101\Program.cs:line 7
```
U ziet dat de niet-verwerkte uitzondering ervoor heeft gezorgd dat uw toepassing wordt afgesloten nadat de eerste Console.WriteLine() instructie is voltooid.

Opmerking

Visual Studio Code gebruikt standaard een andere kleurtekst om berichten weer te geven die zijn gegenereerd door het foutopsporingsprogramma. Dit helpt de ontwikkelaar om onderscheid te maken tussen toepassingsuitvoer en foutopsporingsprogrammaberichten. Als u een schonere weergave van de uitvoer van uw toepassing wilt, kunt u het launch.json-bestand configureren om een andere console te gebruiken. Stel bijvoorbeeld console in op integratedTerminal om het TERMINAL-deelvenster te gebruiken voor toepassingsuitvoer. Foutopsporingsprogramma-berichten worden altijd weergegeven in het paneel DEBUG CONSOLE.

Plaats de twee berekeningen in het codeblok van een try instructie als volgt:

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

Let op de rode golvende lijn onder de sluitende haak van het try blok.

C#-syntaxis vereist een catch of finally component wanneer u een try instructie gebruikt.

Maak als volgt een catch codeblok onder het try codeblok:

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

Selecteer Opslaan in het menu Visual Studio Code File.
Selecteer in het menu Uitvoeren de foutopsporing starten.
Neem even de tijd om de uitvoer te bekijken die uw toepassing heeft geproduceerd.
```
∞
An exception has been caught
Exit program
```
U ziet dat hoewel de uitzondering nog steeds optreedt, uw toepassing de resterende coderegels kan voltooien voordat deze wordt gesloten.

Met uitzonderingsafhandeling kunt u de uitvoering van code beheren wanneer er uitzonderingen optreden. Het afhandelen van uitzonderingen helpt ervoor te zorgen dat uw code stabiel is en de verwachte resultaten produceert.

Vang uitzonderingen die worden opgeworpen in aangeroepen methoden

In veel gevallen wordt er een uitzondering afgevangen op een niveau van de aanroepstack dat lager is dan het niveau waarop deze is geworpen.

Wanneer er een uitzondering optreedt en de huidige methode de uitzondering niet afhandelt, zal de Common Language Runtime de stack afwikkelen op zoek naar een methode die een catch clausule bevat die de uitzondering kan verwerken. De eerste catch component die de uitzondering kan verwerken, wordt uitgevoerd. Als er ergens in de aanroepstack geen geschikte catch component wordt gevonden, beëindigt de algemene taalruntime het proces en wordt er een foutbericht weergegeven aan de gebruiker.

Vervang de code in uw Program.cs bestand door de volgende code:

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

Neem even de tijd om de bijgewerkte code te bekijken.
- De instructies op het hoogste niveau bevatten het try codeblok dat de Process1() methode aanroept.
- De Process1()-methode roept de WriteMessage()-methode aan.
- De WriteMessage() methode bevat de code waarin de DivideByZeroException uitzondering wordt gegenereerd.
Merk op dat de uitzondering wordt gegenereerd in een methode die twee aanroepniveaus boven de try en catch codeblokken ligt.

Instructies op het hoogste niveau worden weergegeven als een methode met de naam Main in de aanroepstack.
Selecteer Opslaan in het menu Visual Studio Code File.
Selecteer in het menu Uitvoeren de foutopsporing starten.
Neem even de tijd om de uitvoer te bekijken die uw toepassing heeft geproduceerd.
```
∞
An exception has occurred
Exit program
```
U ziet dat hoewel de uitzondering twee niveaus hoger in de aanroepstack wordt gegenereerd, deze nog steeds met succes wordt afgehandeld.

Samenvatting

Hier volgen enkele belangrijke dingen die u in deze les moet onthouden:

Implementeer een try-catch patroon voor try opgegeven coderegels binnen uw toepassing en catch uitzonderingen die zich voordoen binnen het bereik van het try codeblok.
Gebruik een catch component om een uitzondering te ondervangen die is gegenereerd op hetzelfde niveau van de aanroepstack.
Gebruik een catch component om een uitzondering te ondervangen die is gegenereerd op een hoger niveau van de aanroepstack.

Feedback

Is deze pagina nuttig?