Delen via

Afhandeling van uitzonderingen en uitzonderingen

  • Artikel

De functies voor het verwerken van uitzonderingen in 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 trycatch, en finally trefwoorden om acties te proberen die mogelijk niet slagen, om fouten af te handelen wanneer u besluit dat dit redelijk is en om resources daarna 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, wordt de stack door de CLR ontspannen, 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 wordt een methode getest voor deling door nul en wordt de fout ondervangen. Zonder de 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("{0} divided by {1} = {2}", a, b, result);
        }
        catch (DivideByZeroException)
        {
            Console.WriteLine("Attempted divide by zero.");
        }
    }
}

Overzicht van uitzonderingen

Uitzonderingen hebben de volgende eigenschappen:

  • Uitzonderingen zijn typen die uiteindelijk afkomstig zijn 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 stroom van het besturingselement naar de eerste gekoppelde 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, wordt het programma niet meer uitgevoerd met een foutbericht.
  • Neem geen uitzondering op, tenzij u deze kunt verwerken en de toepassing in een bekende status kunt achterlaten. Als u het ophaalt System.Exception, kunt u het opnieuw uitvoeren met behulp van het throw trefwoord aan het einde van het catch blok.
  • Als een blok een catch 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 op het win32 gestructureerde mechanisme voor het verwerken van uitzonderingen. Zie Structured Exception Handling (C/C++) en een crashcursus 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