Try/Catch in C# (Wie es für Entwickler funktioniert)

Was sind Ausnahmen, und warum sollte man sie behandeln?

In C# stellt eine Ausnahme ein Ereignis dar, das während der Ausführung eines Programms auftritt und den normalen Ablauf der Programmausführung stört. Wenn eine Ausnahme auftritt, wird der Programmablauf umgeleitet, und wenn die Ausnahme nicht behandelt wird, beendet das Programm abrupt.

Die Ausnahmebehandlung ist eine Möglichkeit, diese störenden Ereignisse vorherzusehen und zu verwalten, sodass Ihr Programm sich von unerwarteten Problemen erholen und wie vorgesehen weiterlaufen kann. Durch die Verwendung von try- und catch-Blöcken können Sie sicherstellen, dass Ihr Code Fehler anmutig behandelt und den Benutzern sinnvolles Feedback gibt.

Der Versuchsblock

Ein Try-Block ist ein Codeabschnitt, von dem Sie erwarten, dass er Ausnahmen erzeugen könnte. Wenn Sie Ihren Code in einem Try-Block umschließen, geben Sie dem Compiler an, dass Sie potenzielle Ausnahmen, die innerhalb dieses Blocks auftreten könnten, behandeln möchten.

Hier ist ein einfaches Beispiel, wie man einen Try-Block verwendet:

try
{
    // Code that may generate an exception
}
catch (Exception ex)
{
    // Handle the exception
}

try
{
    // Code that may generate an exception
}
catch (Exception ex)
{
    // Handle the exception
}

Try
	' Code that may generate an exception
Catch ex As Exception
	' Handle the exception
End Try

Catch Block Catching Ausnahmen

Die Catch-Anweisung wird in Verbindung mit einem Try-Block verwendet, um Ausnahmen zu behandeln. Wenn innerhalb eines Try-Blocks eine Ausnahme auftritt, springt die Programmausführung zum entsprechenden Catch-Block, in dem Sie festlegen können, was das Programm als Reaktion auf die Ausnahme tun soll.

Um eine Ausnahme aufzufangen, müssen Sie unmittelbar nach dem Try-Block einen Catch-Block erstellen. Ein Catch-Block enthält typischerweise einen Parameter, der die gefangene Ausnahme darstellt.

Hier ist ein Beispiel für eine Catch-Anweisung in Aktion:

try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("An error occurred: " + ex.Message);
}

try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("An error occurred: " + ex.Message);
}

Try
	Dim result As Integer = 10 \ 0
Catch ex As DivideByZeroException
	Console.WriteLine("An error occurred: " & ex.Message)
End Try

In diesem Beispiel versucht der Code innerhalb des Try-Blocks, durch Null zu teilen, was eine DivideByZeroException erzeugt. Der Catch-Block behandelt dann die Ausnahme, indem er dem Benutzer eine Nachricht anzeigt.

Mehrere Catch-Blöcke zur Behandlung verschiedener Ausnahmen

Manchmal könnte Ihr Try-Block verschiedene Arten von möglichen Ausnahmen erzeugen. In solchen Fällen können Sie mehrere Catch-Blöcke verwenden, um jeden Ausnahmetyp separat zu behandeln.

Das folgende Beispiel demonstriert die Verwendung mehrerer Catch-Blöcke:

try
{
    int[] numbers = new int[7];
    numbers[12] = 70; // This line will throw an exception
}
catch (IndexOutOfRangeException ex)
{
    Console.WriteLine("An index out of range error occurred: " + ex.Message);
}
catch (Exception e)
{
    Console.WriteLine("An unexpected error occurred: " + e.Message);
}

try
{
    int[] numbers = new int[7];
    numbers[12] = 70; // This line will throw an exception
}
catch (IndexOutOfRangeException ex)
{
    Console.WriteLine("An index out of range error occurred: " + ex.Message);
}
catch (Exception e)
{
    Console.WriteLine("An unexpected error occurred: " + e.Message);
}

Try
	Dim numbers(6) As Integer
	numbers(12) = 70 ' This line will throw an exception
Catch ex As IndexOutOfRangeException
	Console.WriteLine("An index out of range error occurred: " & ex.Message)
Catch e As Exception
	Console.WriteLine("An unexpected error occurred: " & e.Message)
End Try

In diesem Beispiel versucht der Code im Try-Block, einem Array-Index, der nicht existiert, einen Wert zuzuweisen, wodurch eine IndexOutOfRangeException erzeugt wird. Der erste Catch-Block behandelt diese spezifische Ausnahme, während der zweite Catch-Block alle anderen möglicherweise auftretenden Ausnahmen auffängt.

Denken Sie daran, beim Verwenden mehrerer Catch-Blöcke immer von den spezifischsten zu den allgemeineren Ausnahmetypen zu gehen.

Ausnahmefilter, die Bedingungen zu Catch-Blöcken hinzufügen

Ausnahmenfilter ermöglichen es Ihnen, Bedingungen zu Catch-Blöcken hinzuzufügen, sodass Sie Ausnahmen nur abfangen, wenn eine bestimmte Bedingung erfüllt ist. Um einen Ausnahmenfilter zu verwenden, fügen Sie dem Catch-Block das Schlüsselwort when gefolgt von einer Bedingung hinzu.

Das folgende Beispiel demonstriert die Verwendung von Ausnahmenfiltern:

try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex) when (ex.Message.Contains("divide"))
{
    Console.WriteLine("An error occurred: " + ex.Message);
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("A different divide by zero error occurred: " + ex.Message);
}

try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex) when (ex.Message.Contains("divide"))
{
    Console.WriteLine("An error occurred: " + ex.Message);
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("A different divide by zero error occurred: " + ex.Message);
}

Try
	Dim result As Integer = 10 \ 0
Catch ex As DivideByZeroException When ex.Message.Contains("divide")
	Console.WriteLine("An error occurred: " & ex.Message)
Catch ex As DivideByZeroException
	Console.WriteLine("A different divide by zero error occurred: " & ex.Message)
End Try

Im obigen Beispiel wird der erste Catch-Block die DivideByZeroException nur dann behandeln, wenn die Ausnahmemeldung das Wort 'divide' enthält. Wenn die Bedingung nicht erfüllt ist, wird der zweite Catch-Block die Ausnahme behandeln.

Der Finally Block stellt die Codeausführung sicher

In einigen Fällen möchten Sie sicherstellen, dass ein bestimmter Codeabschnitt ausgeführt wird, egal ob eine Ausnahme auftritt oder nicht. Um dies zu erreichen, können Sie einen finally-Block verwenden.

Ein finally-Block wird nach den Try- und Catch-Blöcken platziert und wird immer ausgeführt, unabhängig davon, ob eine Ausnahme auftritt.

Hier ist ein Beispiel, das die Verwendung eines finally-Blocks demonstriert:

try
{
    int result = 10 / 2;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("An error occurred: " + ex.Message);
}
finally
{
    Console.WriteLine("This line will always be executed.");
}

try
{
    int result = 10 / 2;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("An error occurred: " + ex.Message);
}
finally
{
    Console.WriteLine("This line will always be executed.");
}

Try
	Dim result As Integer = 10 \ 2
Catch ex As DivideByZeroException
	Console.WriteLine("An error occurred: " & ex.Message)
Finally
	Console.WriteLine("This line will always be executed.")
End Try

Im obigen Beispiel wird der finally-Block selbst dann ausgeführt, wenn der Code innerhalb des Try-Blocks keine Ausnahme erzeugt.

Benutzerdefinierte Ausnahmen: Exceptions auf Ihre Bedürfnisse zuschneiden

Manchmal möchten Sie Ihre eigenen benutzerdefinierten Ausnahmen erstellen, um spezifische Ausnahmen in Ihrem Code zu behandeln. Dazu können Sie eine neue Klasse erstellen, die von der Exception-Klasse erbt.

Hier ist ein Beispiel zum Erstellen einer benutzerdefinierten Ausnahme:

public class CustomException : Exception
{
    public CustomException(string errorMessage) : base(errorMessage)
    {
    }
}

public class CustomException : Exception
{
    public CustomException(string errorMessage) : base(errorMessage)
    {
    }
}

Public Class CustomException
	Inherits Exception

	Public Sub New(ByVal errorMessage As String)
		MyBase.New(errorMessage)
	End Sub
End Class

Jetzt können Sie diese benutzerdefinierte Ausnahme in Ihren Try- und Catch-Blöcken verwenden, wie folgt:

try
{
    throw new CustomException("This is a custom exception.");
}
catch (CustomException ex)
{
    Console.WriteLine("A custom exception occurred: " + ex.Message);
}

try
{
    throw new CustomException("This is a custom exception.");
}
catch (CustomException ex)
{
    Console.WriteLine("A custom exception occurred: " + ex.Message);
}

Try
	Throw New CustomException("This is a custom exception.")
Catch ex As CustomException
	Console.WriteLine("A custom exception occurred: " & ex.Message)
End Try

In diesem Beispiel wirft der Try-Block eine Instanz der CustomException, die dann vom Catch-Block aufgefangen und behandelt wird.

IronPDF: Integration von PDF-Funktionalität mit Ausnahmebehandlung

Erfahren Sie mehr über IronPDF ist eine beliebte Bibliothek zum Erstellen, Bearbeiten und Extrahieren von Inhalten aus PDF-Dateien in C#. In diesem Abschnitt werden wir erkunden, wie Sie IronPDF mit Ihrem Try-Catch-Ausnahmebehandlungsansatz integrieren können, um potenzielle Fehler anmutig zu behandeln.

Install-Package IronPdf

using IronPdf;
using System;

try
{
    var renderer = new ChromePdfRenderer();
    string html = "Hello, World!";
    PdfDocument PDF = renderer.RenderHtmlAsPdf(html);
    PDF.SaveAs("output.PDF");
    Console.WriteLine("PDF created successfully.");
}
catch (Exception ex)
{
    Console.WriteLine("An unexpected error occurred: " + ex.Message);
}

using IronPdf;
using System;

try
{
    var renderer = new ChromePdfRenderer();
    string html = "Hello, World!";
    PdfDocument PDF = renderer.RenderHtmlAsPdf(html);
    PDF.SaveAs("output.PDF");
    Console.WriteLine("PDF created successfully.");
}
catch (Exception ex)
{
    Console.WriteLine("An unexpected error occurred: " + ex.Message);
}

Imports IronPdf
Imports System

Try
	Dim renderer = New ChromePdfRenderer()
	Dim html As String = "Hello, World!"
	Dim PDF As PdfDocument = renderer.RenderHtmlAsPdf(html)
	PDF.SaveAs("output.PDF")
	Console.WriteLine("PDF created successfully.")
Catch ex As Exception
	Console.WriteLine("An unexpected error occurred: " & ex.Message)
End Try

using IronPdf;
using System;
using System.IO;

try
{
    string pdfPath = "input.PDF";
    if (File.Exists(pdfPath))
    {
        PdfDocument PDF = PdfDocument.FromFile(pdfPath);
        string extractedText = PDF.ExtractAllText();
        Console.WriteLine("Text extracted successfully: " + extractedText);
    }
    else
    {
        Console.WriteLine("The specified PDF file does not exist.");
    }
}
catch (Exception ex)
{
    Console.WriteLine("An unexpected error occurred: " + ex.Message);
}

using IronPdf;
using System;
using System.IO;

try
{
    string pdfPath = "input.PDF";
    if (File.Exists(pdfPath))
    {
        PdfDocument PDF = PdfDocument.FromFile(pdfPath);
        string extractedText = PDF.ExtractAllText();
        Console.WriteLine("Text extracted successfully: " + extractedText);
    }
    else
    {
        Console.WriteLine("The specified PDF file does not exist.");
    }
}
catch (Exception ex)
{
    Console.WriteLine("An unexpected error occurred: " + ex.Message);
}

Imports IronPdf
Imports System
Imports System.IO

Try
	Dim pdfPath As String = "input.PDF"
	If File.Exists(pdfPath) Then
		Dim PDF As PdfDocument = PdfDocument.FromFile(pdfPath)
		Dim extractedText As String = PDF.ExtractAllText()
		Console.WriteLine("Text extracted successfully: " & extractedText)
	Else
		Console.WriteLine("The specified PDF file does not exist.")
	End If
Catch ex As Exception
	Console.WriteLine("An unexpected error occurred: " & ex.Message)
End Try