Introductie over het omgaan met uitzonderingen in Vb.Net
Het volgende artikel Behandeling van uitzonderingen in VB.NET biedt een gedetailleerd overzicht voor de verwerking van uitzonderingen in VB.Net. Welkom bij het onderwerp uitzonderingsbehandeling in VB.NET. Laten we leren wat uitzonderingsbehandeling is, hoe de verschillende uitzonderingen optreden en hoe we omgaan met deze uitzonderingen. Uitzonderingen treden op wanneer we een programma uitvoeren en een fout wordt gevonden die leidt tot een uitzondering die een systeemuitzondering of toepassingsuitzondering kan zijn. We zullen hier meer over leren in de Exception Classes. In dit onderwerp gaan we meer te weten komen over het omgaan met uitzonderingen in VB.NET.
Uitzonderingsafhandeling in VB.NET is gebaseerd op het gebruik van vier trefwoorden zoals proberen, vangen, eindelijk en gooit.
- Try: een Try-blok is een codeblok dat verschillende uitzonderingen binnen de toepassing genereert. Om met deze uitzonderingen in het try-blok om te gaan, gebruiken we catch-blok. Het try-blok wordt dus altijd gevolgd door een of meer catch-blokken.
- Catch: een Catch Block is een codeblok dat de instructies bevat die de uitzonderingen verwerken door een uitzonderingshandler te gebruiken op de instructie waarin het probleem is opgetreden. Het vangstblok is hoofdzakelijk het verwerken van uitzonderingen door verschillende uitzonderingsklassen die zijn gedefinieerd in de bibliotheek met uitzonderingen.
- Eindelijk: een slotblok is een codeblok dat instructies bevat die verplichte instructies zijn die moeten worden uitgevoerd, ongeacht of de uitzondering wordt gegenereerd of niet. Stel dat ik een bestand moet openen, het bestand moet lezen, het bestand moet schrijven en het bestand moet sluiten. In het try-blok zijn statements als een bestand openen, een bestand lezen en een bestand schrijven dat al dan niet een uitzondering genereert, maar het bestand moet worden gesloten voordat het programma eindigt. Het laatste blok bevat dus altijd uitspraken zoals het sluiten van de bestanden, het sluiten van de databaseverbinding, het sluiten van het programma, enz.
- Gooien: wanneer een probleem optreedt, geeft deze verklaring een uitzondering. Deze uitzondering kan worden ingebouwd of door de gebruiker gedefinieerde uitzondering.
Syntaxis
De code voor Try-Catch Block is als volgt
Try
Catch As
(Catch1 Statements) Catch As
(Catch2 Statements) Catch As
(Catch3 Statements) Finally
(Finally Statements) End Try
Hier wordt meer dan één catch-blok weergegeven in de bovenstaande syntaxis om een ander type uitzonderingen op te vangen die door het try-blok worden opgeworpen. Het kan voorkomen dat er meer dan één uitzondering wordt gegenereerd door het try-blok en er slechts één catch-blok beschikbaar is. Om alle uitzonderingen te kunnen opvangen, hebben we een of meerdere catch-statements nodig. En daarom hebben we in de bovenstaande syntaxis meer dan één catch-statement geschreven.
Uitzonderingsklassen in VB.NET
Zoals reeds vermeld in de bovenstaande verklaring. Uitzonderingen zijn van verschillende typen en dit zijn niets anders dan klassen. De bovenliggende klasse waarvan deze klassen zijn geërfd, is System.Exception.
Er zijn hoofdzakelijk twee uitzonderingen
- System.SystemException
- System.ApplicationException
System.SystemException is een klasse voor alle ingebouwde systeemuitzonderingen of we kunnen zeggen dat bij het optreden van een tijdfout de systeemuitzonderingsklassen zoals DivideByZeroException, IndexOutOfRangeException, StackOverflowException worden geïnstantieerd.
System.ApplicationException is een klasse die de uitzonderingen uitvoert die door de programmeur of ontwikkelaar binnen de toepassing zijn gedefinieerd. Het genereert een door de gebruiker gedefinieerde uitzondering die is afgeleid van deze klasse System.ApplicationException.
Laten we eens kijken naar enkele VB.NET-uitzonderingsklassen en het gebruik ervan.
System.IndexOutOfRangeException: deze uitzondering behandelt de fouten die worden veroorzaakt door een array-index die buiten bereik is. Stel dat we een array van 5 array-lengtes hebben en we lopen dit 6 keer voor de 6e keer dat het programma door IndexOutOfRangeException loopt.
System.DivideByZeroException: deze uitzondering behandelt de fouten die worden veroorzaakt wanneer een getal wordt gedeeld door nul, wat in strijd is met de universele regel dat een getal dat wordt gedeeld door nul resulteert in een abnormale beëindiging van het programma.
System.FormatException: deze uitzondering behandelt de fouten die worden veroorzaakt wanneer de gebruiker een teken of een tekenreeks invoert wanneer om een getal of geheel getal wordt gevraagd. stel dat de gebruiker 5 moet invoeren, maar invoer zegt 'y', dan treedt deze uitzondering op.
Voorbeelden van afhandeling van uitzonderingen in VB.NET
Dit zijn enkele uitzonderingen die worden uitgelegd. Laten we nu leren omgaan met deze uitzonderingen in VB.Net met voorbeeld
Voorbeelden # 1
Hieronder staat het programma voor DivideByZeroException en de uitvoer ervan
De code voor het programma
Module exceptionProg
Sub division(ByVal n1 As Integer, ByVal n2 As Integer)
Dim res As Integer
Try
res = n1 \ n2
Catch ex As DivideByZeroException
Console.WriteLine("Exception caught: (0)", ex)
Finally
Console.WriteLine("Result: (0)", res)
End Try
End Sub
Sub Main()
division(100, 0)
Console.ReadKey()
End Sub
End Module
De uitvoer van de code
Voorbeeld 2
Programma voor OverflowException
Module OverFlowProg
Sub division(ByVal n1 As Integer, ByVal n2 As Integer)
Dim res As Integer
Try
res = n1 \ n2
Catch ex As DivideByZeroException
Console.WriteLine("Exception caught: (0)", ex)
Finally
Console.WriteLine("Result: (0)", res)
End Try
End Sub
Sub Main()
division(25, 777777777777)
Console.ReadKey()
End Sub
End Module
De output van de code
Laten we verder onze eigen aangepaste uitzonderingen maken
In dit programma zullen we controleren of het nummer even of oneven is,
Logica: het getal wordt gedeeld door 2 als het resultaat 0 is, is het een even getal, anders is het resultaat een oneven getal als het resultaat niet 0 is.
Code voor het programma is
Module EvenorOddNo
Public Class EvenorOddNo : Inherits ApplicationException
Public Sub New(ByVal message As String)
MyBase.New(message)
End Sub
End Class
Public Class Divide
Dim AnyNo As Integer = 55
Dim No As Integer = 2
Sub showNumber()
If (AnyNo Mod No > 0) Then
Throw (New EvenorOddNo("The number is an odd number"))
Else
Console.WriteLine("The number is an even number : (0)", AnyNo)
End If
End Sub
End Class
Sub Main()
Dim obj As Divide = New Divide()
Try
obj.showNumber()
Catch ex As EvenorOddNo
Console.WriteLine("EvenorOddNo: (0)", ex.Message)
End Try
Console.ReadKey()
End Sub
End Module
De output van het programma
Evenzo, als we het nummer als 100 (in plaats van 55) in het bovenstaande programma invoeren en uitvoeren, wordt de volgende fout weergegeven
Conclusie
Hopelijk heb je het onderwerp Exception Handling in VB.NET begrepen en zul je het kunnen begrijpen met behulp van verschillende voorbeelden die hier worden genoemd
Aanbevolen artikelen
Dit is een handleiding voor het omgaan met uitzonderingen in VB.NET. Hier bespreken we uitzonderingsklassen in VB.NET en voorbeeldcode om de uitzonderingen af te handelen. U kunt ook de volgende artikelen bekijken voor meer informatie -
- VB.NET-besturingselementen
- VB.Net-gegevenstypen
- Wat is ADO.NET?
- Wat is .NET Core
- VB.Net-evenementen