Delen via

Uitzonderingen en afhandeling van uitzonderingen

De uitzonderingsafhandelingsfuncties van de C#-taal helpen u om te gaan met onverwachte of uitzonderlijke situaties die optreden wanneer een programma wordt uitgevoerd. Uitzonderingsafhandeling maakt gebruik van de try, catchen finally trefwoorden om acties te proberen die mogelijk niet slagen, om fouten af te handelen wanneer u besluit dat het redelijk is om dit te doen en om daarna resources op te schonen. Uitzonderingen kunnen worden gegenereerd door de Common Language Runtime (CLR), door .NET- of bibliotheken van derden of door toepassingscode. Uitzonderingen worden gemaakt met behulp van het throw trefwoord.

In veel gevallen kan een uitzondering niet worden gegenereerd door een methode die uw code rechtstreeks heeft aangeroepen, maar door een andere methode verderop in de aanroepstack. Wanneer er een uitzondering wordt gegenereerd, zal de CLR de stack afwikkelen, op zoek naar een methode met een catch blok voor het specifieke uitzonderingstype en wordt het eerste dergelijke catch blok uitgevoerd dat wordt gevonden. Als er ergens in de aanroepstack geen geschikt catch blok wordt gevonden, wordt het proces beëindigd en wordt er een bericht weergegeven aan de gebruiker.

In dit voorbeeld test een methode op delen door nul en vangt de fout op. Zonder uitzonderingsafhandeling zou dit programma worden beëindigd met een DivideByZeroException-fout .

public class ExceptionTest
{
    static double SafeDivision(double x, double y)
    {
        if (y == 0)
            throw new DivideByZeroException();
        return x / y;
    }

    public static void Main()
    {
        // Input for test purposes. Change the values to see
        // exception handling behavior.
        double a = 98, b = 0;
        double result;

        try
        {
            result = SafeDivision(a, b);
            Console.WriteLine($"{a} divided by {b} = {result}");
        }
        catch (DivideByZeroException)
        {
            Console.WriteLine("Attempted divide by zero.");
        }
    }
}

Overzicht van uitzonderingen

Uitzonderingen hebben de volgende eigenschappen:

  • Uitzonderingen zijn typen die uiteindelijk zijn afgeleid van System.Exception.
  • Gebruik een try blok rond de instructies die uitzonderingen kunnen genereren.
  • Zodra er een uitzondering optreedt in het try blok, springt de controlestroom naar de eerste bijbehorende uitzonderingshandler die overal in de aanroepstack aanwezig is. In C# wordt het catch trefwoord gebruikt om een uitzonderingshandler te definiëren.
  • Als er geen uitzonderingshandler voor een bepaalde uitzondering aanwezig is, stopt het programma met een foutbericht.
  • Maak geen uitzondering tenzij u deze kunt afhandelen en de toepassing in een bekende status kunt laten staan. Als je System.Exception opvangt, gooi je het opnieuw met behulp van het throw trefwoord aan het einde van het catch blok.
  • Als een catch blok een uitzonderingsvariabele definieert, kunt u deze gebruiken om meer informatie te verkrijgen over het type uitzondering dat is opgetreden.
  • Uitzonderingen kunnen expliciet worden gegenereerd door een programma met behulp van het throw trefwoord.
  • Uitzonderingsobjecten bevatten gedetailleerde informatie over de fout, zoals de status van de aanroepstack en een tekstbeschrijving van de fout.
  • Code in een finally blok wordt uitgevoerd, ongeacht of er een uitzondering wordt gegenereerd. Gebruik een finally blok om resources vrij te geven, bijvoorbeeld om streams of bestanden te sluiten die in het try blok zijn geopend.
  • Beheerde uitzonderingen in .NET worden geïmplementeerd boven op het win32 structured exception handling mechanisme. Zie Structured Exception Handling (C/C++) en een crash course over de diepten van De verwerking van gestructureerde uitzonderingen in Win32 voor meer informatie.

C#-taalspecificatie

Zie Uitzonderingen in de C#-taalspecificatie voor meer informatie. De taalspecificatie is de definitieve bron voor de C#-syntaxis en het gebruik.

Zie ook