Menu

C # Tutorial voor het afhandelen van uitzonderingen met codevoorbeelden

  • Hoofd
  • Andere
  • C # Tutorial voor het afhandelen van uitzonderingen met codevoorbeelden

c exception handling tutorial with code examples

Probeer Ons Instrument Voor Het Oplossen Van Problemen

Afhandeling van uitzonderingen is een methode om fouten te behandelen die kunnen optreden tijdens de uitvoering van een programma. In deze zelfstudie wordt het afhandelen van uitzonderingen in C # uitgelegd met codevoorbeelden:

hoe je een pot opent met java

Afhandeling van uitzonderingen wordt gebruikt om ervoor te zorgen dat de programmastroom wordt voortgezet, zelfs als er een runtime-fout is. Uitzonderingen zijn de objecten die worden gegenereerd tijdens het optreden van een runtime-fout.

Als de uitzonderingen niet worden afgehandeld, zal C # een uitzonderingsbericht produceren en het programma beëindigen, dit is waar het afhandelen van uitzonderingen in beeld komt.

​ Lees hier de C # -gids voor beginners

Afhandeling van uitzonderingen in C #

Wat je leert:

Wat zijn uitzonderingen?

Uitzonderingen zijn ongekende fouten die tijdens runtime in uw programma kunnen optreden. De meeste tijdprogrammeurs kunnen gemakkelijk enkele van de fouten detecteren, zoals validatie of nulcontrole of tijdens het verifiëren van sommige waarden.

Maar er zijn bepaalde momenten waarop we niet kunnen anticiperen op wat of wanneer er een fout zal verschijnen. Bijvoorbeeld, stel dat ik op een locatie naar een bestand zoek. Mijn programma werkt prima totdat het bestand aanwezig is en als het op de een of andere manier is verwijderd, zal mijn programma een foutmelding geven.

Uitzonderingen komen niet regelmatig voor, maar kunnen toch voorkomen en u zult ze altijd zorgvuldig willen behandelen. Om deze af te handelen gebruiken we exception handling.

Elke keer dat er een fout optreedt, zeggen we dat deze wordt gegooid, 'gegooid' is een object van System.Exception klasse in C #. De System.Exception class biedt verschillende methoden en eigenschappen die details geven over de fout die uw programma zojuist is tegengekomen.

Zoals de eigenschap stacktracering die de stack geeft waarvoor het probleem is opgetreden of de eigenschap Message die een beschrijving van de uitzondering geeft.

wat is het gebruik van maven in selenium

Sleutelwoorden voor het afhandelen van uitzonderingen

Uitzonderingen bieden een proces om een ​​bepaald deel van het programma te besturen, zodat zelfs als er een uitzondering is in dat deel, de programmabesturing wordt overgedragen naar een ander deel van het programma. In C # is de afhandeling van uitzonderingen in feite opgebouwd rond vier trefwoorden: gooien, proberen, vangen en tenslotte ​

werpen

Zoals we al hebben besproken, is throw een object van System.Exception klasse in de C #. Het staat het programma toe om een ​​fout te genereren wanneer het er een tegenkomt.

proberen

Probeer blok omsluit het blok van de code die ervoor kan zorgen dat het programma een uitzondering genereert. Het wordt gevolgd door een of meer catch-blokken.

vangst

Wanneer try block een exception tegenkomt, biedt het de controle aan het catch-blok om de exception te vangen. Het catch-blok kan ook een set codes bevatten die het programma moet uitvoeren in het geval van een exception of het kan gewoon de exception opvangen en niets doen, afhankelijk van het scenario en de vereiste.

Tenslotte

Het laatste blok wordt gebruikt om een ​​bepaald codefragment of instructie uit te voeren, ongeacht het optreden van een uitzondering. Tenslotte wordt blok altijd uitgevoerd, en het kan worden uitgevoerd net na het try-blok als het programma geen uitzondering vindt, of het kan worden uitgevoerd na het catch-blok zodra het programma een exception opvangt.

Uitzonderingsklassen aanwezig in C #

Alle uitzonderingen in de C # zijn direct of indirect afgeleid van de System.Exception klasse.

Laten we een korte blik werpen op enkele van de meest voorkomende uitzonderingen:

  • System.IO.IO Uitzondering: Het behandelt alle invoer- en uitvoergerelateerde fouten.
  • System.DividedByZeroException: Verwerkt fouten die worden gegenereerd wanneer een getal wordt gedeeld door nul.
  • System.NullReferenceException : Verwerkt elke fout die kan optreden wanneer naar een null-object wordt verwezen.
  • System.IndexOutOfRangeException: Verwerkt de fout die wordt gegenereerd wanneer een programma probeert toegang te krijgen tot een index die buiten het bereik van de array valt.
  • System.OutOfMemoryException: Verwerkt fouten die worden veroorzaakt door onvoldoende geheugen.

Afhandeling van uitzonderingen in C #

C # heeft een zeer goed gedefinieerde oplossing voor het afhandelen van elk type uitzondering dat kan optreden door het try and catch-blok te gebruiken. Met behulp van dit blok kan de kernverklaring van het programma worden gescheiden van de andere verklaringen.

Voorbeeld:

​

In het bovenstaande voorbeeld hebben we onze code voor het openen van een bestand ingesloten onder het try-blok. Omdat we geen geldig bestandspad hebben opgegeven, zou de code een fout moeten genereren. Nu hebben we de fout in ons catch-blok opgevangen. Als het bestand niet bestaat in het opgegeven bestandspad, zal de code een FileNotFoundException genereren.

Deze uitzondering wordt opgevangen door het catch-blok waar we de verwachte uitzondering al hebben gedefinieerd. Laten we ons nu voorstellen dat als onze code een andere uitzondering genereert dan degene die we al hebben gedefinieerd, dan kan ons blok het niet opvangen. Om een ​​generieke uitzondering op te vangen, zullen we nog een catch-blok toevoegen.

Laten we eens kijken naar onze bijgewerkte code:

​

Dit generieke catch-blok kan alle uitzonderingen opvangen die in het try-blok kunnen worden gegooid. Laten we nu ook een laatste blok toevoegen om dit te voltooien. Om het simpel te maken, laten we gewoon een bericht afdrukken met het blok eindelijk.

wat is de gebruikersnaam en het wachtwoord van mijn router
​

Hier hebben we zojuist het laatste blok toegevoegd met een eenvoudig bericht. U kunt ook enkele aangepaste instructies in het blok toevoegen. Maar de algemene structuur van het programma blijft vergelijkbaar met degene die hier wordt weergegeven.

Het blok Eindelijk wordt altijd uitgevoerd, ongeacht of er een uitzondering is of niet. Het programma start vanaf het try-blok en gaat dan direct naar het final-blok als er geen fouten / uitzonderingen zijn. Als het een uitzondering tegenkomt, zal het eerst naar catch gaan en dan het laatste blok uitvoeren.

Is er een voorwaarde dat het laatste blok niet wordt uitgevoerd?

Zoals de naam suggereert, wordt het laatste blok aan het einde uitgevoerd en is het het laatste blok van de code die zal worden uitgevoerd. Ten slotte wordt block altijd uitgevoerd als de applicatie actief is. De enige keer dat het uiteindelijke blok niet wordt uitgevoerd, is wanneer de toepassing crasht of opzettelijk wordt gedood met het procescommando.

Gevolgtrekking

Als uitzonderingen niet correct worden afgehandeld, veroorzaken ze fouten in uw programma. Als je nergens in je code try / catch-blokken hebt gebruikt, wordt je programma afgebroken met een bericht met de uitzondering. Voor een generieke gebruiker zal het erg moeilijk zijn om de fout terug te traceren naar de broncode en deze op te lossen.

Daarom is het altijd een goede gewoonte om uitzonderingen in uw programma af te handelen.

Voorbeeldcode

​

​ Bekijk hier onze complete C #-trainingsserie

Aanbevolen literatuur

^