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
}

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);
}

In diesem Beispiel versucht der Code im try-Block, durch null zu teilen, was einen 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);
}

In diesem Beispiel versucht der Code im try-Block, einem nicht existierenden Array-Index einen Wert zuzuweisen, was einen IndexOutOfRangeException erzeugt. 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 Ausnahmefilter zu verwenden, fügen Sie das Schlüsselwort when gefolgt von einer Bedingung in Ihrer catch-Anweisung 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);
}

Im obigen Beispiel wird der erste catch-Block den 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 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.");
}

Im obigen Beispiel wird der finally Block auch dann ausgeführt, wenn der Code im try-Block 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. Um dies zu tun, 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)
    {
    }
}

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);
}

In diesem Beispiel wirft der try-Block eine CustomException Instanz, die dann vom catch-Block abgefangen 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);
}

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);
}