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

Wenn Sie neu in der Programmierung in C# sind, haben Sie vielleicht schon einmal den Begriff "try catch"-Anweisung gehört, der häufig verwendet wird. In diesem Tutorial tauchen wir in die Welt der Ausnahmebehandlung ein, wobei wir uns auf Catch-Blöcke konzentrieren und untersuchen, wie Sie Try- und Catch-Anweisungen verwenden können, um Ihren Code widerstandsfähiger gegen Fehler zu machen. Dabei werden wir viele Beispiele aus der Praxis anführen, um Ihr Verständnis zu vertiefen.

Was sind Ausnahmen, und warum sollte man sie behandeln?

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

Die Behandlung von Ausnahmen ist eine Möglichkeit, diese störenden Ereignisse zu antizipieren und zu verwalten, so dass sich Ihr Programm 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 ordnungsgemäß behandelt und den Benutzern ein aussagekräftiges Feedback gibt.

Der Versuchsblock

Ein Try-Block ist ein Codesegment, von dem Sie erwarten, dass es zu Ausnahmen kommen kann. Wenn Sie Ihren Code in einen Try-Block einschließen, teilen Sie dem Compiler mit, dass Sie potenzielle Ausnahmen, die innerhalb dieses Blocks auftreten können, behandeln möchten.

Hier ist ein einfaches Beispiel für die Verwendung eines Try-Blocks:

    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 Abfangen von 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 in den entsprechenden Catch-Block, in dem Sie angeben können, was das Programm als Reaktion auf die Ausnahme tun soll.

Um eine Ausnahme abzufangen, müssen Sie unmittelbar nach dem try-Block einen catch-Block erstellen. Ein Catch-Block enthält normalerweise einen Parameter, der die abgefangene 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 dividieren, was zu einer DivideByZeroException führt. Der Catch-Block behandelt dann die Ausnahme und zeigt dem Benutzer eine Meldung an.

Mehrere Catch-Blöcke, die verschiedene Ausnahmen behandeln

Manchmal kann 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 zeigt die Verwendung von mehreren Catch-Blöcken:

    try
    {
        int [] numbers = new int [7];
        numbers [12] = 70;
    }
    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;
    }
    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
	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 innerhalb des try-Blocks, einem Array-Index einen Wert zuzuweisen, der nicht existiert, was zu einer IndexOutOfRangeException führt. Der erste Catch-Block behandelt diese spezielle Ausnahme, während der zweite Catch-Block jede andere Ausnahme abfängt, die auftreten könnte.

Denken Sie daran, wenn Sie mehrere Catch-Blöcke verwenden, ordnen Sie sie immer von den spezifischsten zu den allgemeinsten Ausnahmetypen.

Ausnahmefilter Hinzufügen von Bedingungen zu Catch-Blöcken

Mit Ausnahmefiltern können Sie Bedingungen zu Abfangblöcken hinzufügen, so dass Sie Ausnahmen nur abfangen können, wenn eine bestimmte Bedingung erfüllt ist. Um einen Ausnahmefilter zu verwenden, fügen Sie das Schlüsselwort when gefolgt von einer Bedingung in Ihre catch-Anweisung ein.

Das folgende Beispiel demonstriert die Verwendung von Ausnahmefiltern:

    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 behandelt der erste Catch-Block die DivideByZeroException nur, wenn die Ausnahmemeldung das Wort "divide" enthält. Wenn die Bedingung nicht erfüllt ist, wird die Ausnahme im zweiten Catch-Block behandelt.

Der Finally-Block sichert die Code-Ausführung

In manchen Fällen möchten Sie vielleicht sicherstellen, dass ein bestimmtes Stück Code ausgeführt wird, unabhängig davon, 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 "final"-Block auch dann ausgeführt, wenn der Code innerhalb des try-Blocks keine Ausnahme erzeugt.

Kundenspezifische Ausnahmen: Maßgeschneiderte Ausnahmen für Ihre Bedürfnisse

Manchmal möchten Sie vielleicht Ihre eigenen benutzerdefinierten Ausnahmen erstellen, um bestimmte Ausnahmen in Ihrem Code zu behandeln. Zu diesem Zweck können Sie eine neue Klasse erstellen, die von der Klasse "Exception" erbt.

Hier ist ein Beispiel für die Erstellung 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, etwa so:

    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 löst der try-Block eine CustomException-Instanz aus, die dann vom catch-Block aufgefangen und behandelt wird.

IronPDF: Integration der PDF-Funktionalität mit Ausnahmebehandlung

IronPDF ist eine beliebte Bibliothek zum Erstellen, Bearbeiten und Extrahieren von Inhalten aus PDF-Dateien in C#. In diesem Abschnitt werden wir untersuchen, wie Sie IronPDF in Ihre try-catch-Ausnahmebehandlung integrieren können, um potenzielle Fehler elegant zu behandeln.

Installation von IronPDF

Um loszulegen, müssen Sie zunächst das IronPDF NuGet-Paket installieren. Sie können dies über die Paketmanager-Konsole tun:

Install-Package IronPdf

Oder Sie können im Dialogfeld "NuGet-Pakete verwalten" in Visual Studio nach "IronPDF" suchen.

Erstellen einer PDF-Datei mit IronPDF und Behandlung von Ausnahmen

Nehmen wir an, Sie möchten eine PDF-Datei aus einer HTML-Datei erstellen zeichenfolge mit IronPDF. Da bei der Erstellung einer PDF-Datei Ausnahmen auftreten können, können Sie try-catch-Blöcke verwenden, um diese zu behandeln. Hier ist ein Beispiel, wie Sie mit IronPDF ein PDF-Dokument erstellen und Ausnahmen mit try-catch behandeln können:

    using IronPdf;
    using System;
    try
    {
        var renderer = new IronPDF.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 IronPDF.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 IronPDF.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

In diesem Beispiel enthält der try-Block den Code zum Erstellen einer PDF-Datei mit IronPDF. Wenn während des Prozesses eine Ausnahme auftritt, behandeln die Catch-Blöcke den Fehler und zeigen dem Benutzer eine entsprechende Fehlermeldung an.

Text aus einer PDF-Datei extrahieren und Ausnahmen behandeln

Sie können auch mit IronPDF Text aus einer PDF-Datei extrahieren. Wie im vorherigen Beispiel können Sie try-catch-Blöcke verwenden, um mögliche Ausnahmen zu behandeln.

Hier ein Beispiel für die Extraktion von Text aus einer PDF-Datei mit IronPDF und die Behandlung von Ausnahmen:

    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

In diesem Beispiel enthält der try-Block den Code zum Extrahieren von Text aus einer PDF-Datei mit IronPDF. Wenn während des Prozesses eine Ausnahme auftritt, behandeln die Catch-Blöcke den Fehler und zeigen dem Benutzer eine entsprechende Meldung an.

Schlussfolgerung

Durch die Kombination IronPDF mit Ihrem try-catch-Ausnahmebehandlungsansatz können Sie robuste Anwendungen erstellen, die Fehler bei der Arbeit mit PDF-Dateien zuverlässig behandeln. Dadurch wird nicht nur die Stabilität Ihrer Anwendungen verbessert, sondern auch die allgemeine Benutzerfreundlichkeit erhöht.

Denken Sie bei der Arbeit mit externen Bibliotheken wie IronPDF immer an mögliche Ausnahmen und behandeln Sie diese angemessen mit try- und catch-Anweisungen. Auf diese Weise können Sie sicherstellen, dass Ihre Anwendungen auch bei unerwarteten Problemen belastbar und benutzerfreundlich sind.

IronPDF bietet eine kostenloser Testso können Sie die Möglichkeiten des Systems unverbindlich testen. Wenn Sie sich entscheiden, IronPDF nach der Testphase weiter zu nutzen, beginnt die Lizenzierung mit $749,