C# - Afhandeling van uitzonderingen

Een uitzondering is een probleem dat zich voordoet tijdens de uitvoering van een programma. Een C#-uitzondering is een reactie op een uitzonderlijke omstandigheid die zich voordoet terwijl een programma draait, zoals een poging om te delen door nul.

Uitzonderingen bieden een manier om de controle over te dragen van het ene deel van een programma naar het andere. De afhandeling van C#-uitzonderingen is gebaseerd op vier sleutelwoorden:proberen , vangen , eindelijk , en gooi .

• probeer − Een try-blok identificeert een codeblok waarvoor bepaalde uitzonderingen zijn geactiveerd. Het wordt gevolgd door een of meer vangblokken.

• vang − Een programma vangt een uitzondering op met een uitzonderingshandler op de plaats in een programma waar u het probleem wilt oplossen. Het catch-sleutelwoord geeft het opvangen van een uitzondering aan.

• eindelijk − Het final-blok wordt gebruikt om een ​​bepaalde set instructies uit te voeren, ongeacht of er een uitzondering wordt gegenereerd of niet. Als u bijvoorbeeld een bestand opent, moet het worden gesloten, ongeacht of er een uitzondering wordt gemaakt of niet.

• gooi − Een programma genereert een uitzondering wanneer zich een probleem voordoet. Dit wordt gedaan met behulp van een zoekwoord.

Syntaxis

Ervan uitgaande dat een blok een uitzondering genereert, vangt een methode een uitzondering op met een combinatie van de trefwoorden try en catch. Om de code wordt een try/catch-blok geplaatst dat een uitzondering zou kunnen genereren. Code binnen een try/catch-blok wordt beschermde code genoemd en de syntaxis voor het gebruik van try/catch ziet er als volgt uit −

try {
   // statements causing exception
} catch( ExceptionName e1 ) {
   // error handling code
} catch( ExceptionName e2 ) {
   // error handling code
} catch( ExceptionName eN ) {
   // error handling code
} finally {
   // statements to be executed
}

U kunt meerdere catch-statements opsommen om verschillende soorten uitzonderingen op te vangen voor het geval uw try-blok in verschillende situaties meer dan één uitzondering oproept.

Uitzonderingsklassen in C#

C#-uitzonderingen worden weergegeven door klassen. De uitzonderingsklassen in C# zijn voornamelijk direct of indirect afgeleid van de System.Exception klas. Enkele van de uitzonderingsklassen die zijn afgeleid van de klasse System.Exception zijn de System.ApplicationException en System.SystemException lessen.

De System.ApplicationException class ondersteunt uitzonderingen die worden gegenereerd door toepassingsprogramma's. Vandaar dat de uitzonderingen gedefinieerd door de programmeurs uit deze klasse zouden moeten voortkomen.

De System.SystemException class is de basisklasse voor alle vooraf gedefinieerde systeemuitzonderingen.

De volgende tabel bevat enkele van de vooraf gedefinieerde uitzonderingsklassen die zijn afgeleid van de Sytem.SystemException-klasse −

Uitzonderingen afhandelen

C# biedt een gestructureerde oplossing voor het afhandelen van uitzonderingen in de vorm van try-and-catch-blokken. Met behulp van deze blokken worden de kernprogramma-statements gescheiden van de error-handling-statements.

Deze foutafhandelingsblokken worden geïmplementeerd met behulp van de try , vangen , en eindelijk trefwoorden. Hieronder volgt een voorbeeld van het genereren van een uitzondering wanneer de voorwaarde wordt gedeeld door nul −

using System;

namespace ErrorHandlingApplication {
   class DivNumbers {
      int result;
      
      DivNumbers() {
         result = 0;
      }
      public void division(int num1, int num2) {
         try {
            result = num1 / num2;
         } catch (DivideByZeroException e) {
            Console.WriteLine("Exception caught: {0}", e);
         } finally {
            Console.WriteLine("Result: {0}", result);
         }
      }
      static void Main(string[] args) {
         DivNumbers d = new DivNumbers();
         d.division(25, 0);
         Console.ReadKey();
      }
   }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

Exception caught: System.DivideByZeroException: Attempted to divide by zero. 
at ...
Result: 0

Door de gebruiker gedefinieerde uitzonderingen maken

U kunt ook uw eigen uitzondering definiëren. Door de gebruiker gedefinieerde uitzonderingsklassen zijn afgeleid van de Uitzondering klas. Het volgende voorbeeld laat dit zien −

using System;

namespace UserDefinedException {
   class TestTemperature {
      static void Main(string[] args) {
         Temperature temp = new Temperature();
         try {
            temp.showTemp();
         } catch(TempIsZeroException e) {
            Console.WriteLine("TempIsZeroException: {0}", e.Message);
         }
         Console.ReadKey();
      }
   }
}
public class TempIsZeroException: Exception {
   public TempIsZeroException(string message): base(message) {
   }
}
public class Temperature {
   int temperature = 0;
   
   public void showTemp() {
      
      if(temperature == 0) {
         throw (new TempIsZeroException("Zero Temperature found"));
      } else {
         Console.WriteLine("Temperature: {0}", temperature);
      }
   }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

TempIsZeroException: Zero Temperature found

Objecten gooien

U kunt een object gooien als het direct of indirect is afgeleid van de System.Exception klas. Je kunt een throw-statement in het catch-blok gebruiken om het huidige object te gooien als −

Catch(Exception e) {
   ...
   Throw e
}