C# Catch Multiple Exceptions (Wie es funktioniert für Entwickler)

Behandlung von Ausnahmen ist in C# unerlässlich. Dieses Tutorial zeigt Ihnen, wie Sie einen try-catch-Block mit mehreren catch-Klauseln verwenden können. Wir werden uns damit beschäftigen, wie man mehrere Ausnahmetypen abfängt, Ausnahmefilter verwendet und sicherstellt, dass die Ressourcen endgültig bereinigt werden. Ziel ist es, Sie bei der Erstellung robuster und fehlertoleranter C#-Anwendungen zu unterstützen.

Wenn Sie lernen, mehrere Arten von Ausnahmen abzufangen, können Sie auf bestimmte Probleme reagieren und so die Zuverlässigkeit Ihres Programms verbessern. Wir werden auch darauf eingehen, wie man mit dem Schlüsselwort when Bedingungen auf Catch-Blöcke anwenden kann, was eine präzisere Fehlerbehandlung ermöglicht.

Dieser Leitfaden vermittelt Ihnen die Methoden, mit denen Sie Ausnahmen abfangen und sowohl häufige als auch komplexe Fehler in Ihren Codierungsprojekten reibungslos behandeln können. Wir werden auch Folgendes erforschen IronPDF im Zusammenhang mit der Behandlung von Ausnahmen.

Was ist Ausnahmebehandlung?

Die Ausnahmebehandlung in C# ist eine Methode zur Behandlung von Laufzeitfehlern, zur Verhinderung eines abrupten Programmabbruchs und zur Bewältigung unerwarteter Situationen, wenn diese während der Ausführung eines Programms auftreten. Zu den Kernkomponenten der Ausnahmebehandlung gehören die Blöcke try, catch und finally.

Grundlegende Struktur von Try-Catch in C##

Der Try-Block enthält Code, der möglicherweise eine Ausnahme auslösen könnte, während der Catch-Block für die Verwaltung der Ausnahme verantwortlich ist, wenn sie auftritt. Der finally-Block ist optional und führt Code nach den try- und catch-Blöcken aus, unabhängig davon, ob eine Ausnahme ausgelöst wurde oder nicht. Hier ist eine einfache Struktur:

try {
    // Code that may throw an exception
}
catch (Exception e) {
    // Code to handle the exception
}
finally {
    // Code that executes after try and catch, regardless of an exception
}

try {
    // Code that may throw an exception
}
catch (Exception e) {
    // Code to handle the exception
}
finally {
    // Code that executes after try and catch, regardless of an exception
}

Try
	' Code that may throw an exception
Catch e As Exception
	' Code to handle the exception
Finally
	' Code that executes after try and catch, regardless of an exception
End Try

Mehrere Ausnahmen abfangen

In realen Anwendungen kann eine einzige Operation Ausnahmen verschiedener Typen auslösen. In C# können Sie daher mehrere "Catch"-Blöcke für einen einzigen "Try"-Block definieren. Jeder catch-Block kann einen anderen Ausnahmetyp angeben, um alle Ausnahmen zu behandeln.

Warum mehrere Ausnahmen abfangen?

Das Auffangen mehrerer Ausnahmen ist für eine detaillierte Fehlerbehandlung unerlässlich, bei der die Aktionen vom aufgetretenen spezifischen Fehler abhängen. Sie ermöglicht es den Entwicklern, jede Ausnahme auf eine Weise zu behandeln, die dem Kontext des jeweiligen Fehlers angemessen ist.

Wie man mehrere Auffangblöcke implementiert

Hier ein Beispiel für die Implementierung eines einzelnen Catch-Blocks zum Abfangen mehrerer Ausnahmetypen:

try {
    // Code that may throw multiple types of exceptions
    int[] numbers = {1, 2, 3};
    Console.WriteLine(numbers[5]); // This will throw an IndexOutOfRangeException
}
catch (IndexOutOfRangeException ex) {
    Console.WriteLine("An index was out of range: " + ex.Message);
}
catch (DivideByZeroException ex) {
    Console.WriteLine("Can't divide by Zero: " + ex.Message);
}
catch (Exception ex) {
    Console.WriteLine("Error: " + ex.Message);
}

try {
    // Code that may throw multiple types of exceptions
    int[] numbers = {1, 2, 3};
    Console.WriteLine(numbers[5]); // This will throw an IndexOutOfRangeException
}
catch (IndexOutOfRangeException ex) {
    Console.WriteLine("An index was out of range: " + ex.Message);
}
catch (DivideByZeroException ex) {
    Console.WriteLine("Can't divide by Zero: " + ex.Message);
}
catch (Exception ex) {
    Console.WriteLine("Error: " + ex.Message);
}

Try
	' Code that may throw multiple types of exceptions
	Dim numbers() As Integer = {1, 2, 3}
	Console.WriteLine(numbers(5)) ' This will throw an IndexOutOfRangeException
Catch ex As IndexOutOfRangeException
	Console.WriteLine("An index was out of range: " & ex.Message)
Catch ex As DivideByZeroException
	Console.WriteLine("Can't divide by Zero: " & ex.Message)
Catch ex As Exception
	Console.WriteLine("Error: " & ex.Message)
End Try

In diesem Code werden bestimmte Ausnahmen wie "IndexOutOfRangeException" und "DivideByZeroException" durch ihre jeweiligen "Catch"-Blöcke abgefangen. Alle anderen Arten von Ausnahmen werden durch den generischen "Exception"-Catch-Block abgefangen.

Verwendung von Ausnahmefiltern mit dem Schlüsselwort When

C# unterstützt auch Ausnahmefilter, mit denen Sie eine Bedingung innerhalb des Catch-Blocks angeben können. Diese Funktion verwendet das Schlüsselwort when, um mehr Kontrolle darüber zu haben, welche Ausnahmen auf der Grundlage der zur Laufzeit ausgewerteten Bedingung abgefangen werden sollen.

So können Sie mit dem Schlüsselwort when Ausnahmefilter hinzufügen:

try {
    // Code that may throw an exception
    throw new InvalidOperationException("Invalid operation occurred", new Exception("Inner exception"));
}
catch (Exception ex) when (ex.InnerException != null) {
    Console.WriteLine("Exception with inner exception caught: " + ex.Message);
}
catch (Exception ex) {
    Console.WriteLine("Exception caught: " + ex.Message);
}

try {
    // Code that may throw an exception
    throw new InvalidOperationException("Invalid operation occurred", new Exception("Inner exception"));
}
catch (Exception ex) when (ex.InnerException != null) {
    Console.WriteLine("Exception with inner exception caught: " + ex.Message);
}
catch (Exception ex) {
    Console.WriteLine("Exception caught: " + ex.Message);
}

Try
	' Code that may throw an exception
	Throw New InvalidOperationException("Invalid operation occurred", New Exception("Inner exception"))
Catch ex As Exception When ex.InnerException IsNot Nothing
	Console.WriteLine("Exception with inner exception caught: " & ex.Message)
Catch ex As Exception
	Console.WriteLine("Exception caught: " & ex.Message)
End Try

Die Rolle des Endblocks

Der finally-Block wird verwendet, um Code auszuführen, nachdem der try- und alle catch-Blöcke abgeschlossen sind. Es ist nützlich für das Aufräumen von Ressourcen, wie das Schließen von Dateistreams oder Datenbankverbindungen, unabhängig davon, ob eine Ausnahme aufgetreten ist.

try {
    // Code that might throw an exception
}
catch (Exception e) {
    // Handle the exception
}
finally {
    // Cleanup code, executed after try/catch
    Console.WriteLine("Cleanup code runs here.");
}

try {
    // Code that might throw an exception
}
catch (Exception e) {
    // Handle the exception
}
finally {
    // Cleanup code, executed after try/catch
    Console.WriteLine("Cleanup code runs here.");
}

Try
	' Code that might throw an exception
Catch e As Exception
	' Handle the exception
Finally
	' Cleanup code, executed after try/catch
	Console.WriteLine("Cleanup code runs here.")
End Try

Einführung von IronPDF

IronPDF ist eine umfassende Bibliothek für C#-Entwickler, die mit .NET-Anwendungen arbeiten. Es hilft Entwicklern bei der Manipulation, Verwaltung und pDF-Dateien direkt aus HTML erstellen. Sie benötigt keine externe Abhängigkeit, um zu funktionieren.

Sie können jede PDF-Operation durchführen, ohne Adobe Acrobat zu verwenden und zu installieren. IronPDF unterstützt verschiedene PDF-Funktionen wie das Bearbeiten, Zusammenführen, Aufteilen und Sichern von PDF-Dokumenten mit Verschlüsselung und digitalen Signaturen. Entwickler können IronPDF in verschiedenen Anwendungstypen einsetzen, darunter Webanwendungen, Desktopanwendungen und Dienste.

Interlink:

Das Hauptmerkmal von IronPDF ist das Konvertieren HTML zu PDF, das sowohl Layout als auch Stil beibehält. Es ist perfekt zum Erstellen von PDFs aus Webinhalten, egal ob für Berichte, Rechnungen oder Dokumentation. HTML-Dateien, URLs und HTML-Strings können alle in PDF-Dateien konvertiert werden.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Code-Beispiel

Hier ist ein einfaches C#-Beispiel, das IronPDF verwendet, um ein PDF aus HTML zu erstellen, mit Fehlerbehandlung für mehrere Arten von Ausnahmen. Dieses Beispiel setzt voraus, dass Sie IronPDF in Ihrem Projekt installiert haben. Führen Sie diesen Befehl in der NuGet-Konsole aus, um IronPDF zu installieren:

Install-Package IronPdf

Hier ist der Code:

using IronPdf;
using System;
class Program
{
    static void Main(string[] args)
    {
        License.LicenseKey = "License-Key";
        var renderer = new ChromePdfRenderer();
        try
        {
            // Convert HTML to PDF
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1>");
            pdf.SaveAs("Exceptions.pdf");
            Console.WriteLine("PDF successfully created.");
        }
        catch (IronPdf.Exceptions.IronPdfProductException ex)
        {
            // Handle PDF generation errors
            Console.WriteLine("Failed to generate PDF: " + ex.Message);
        }
        catch (System.IO.IOException ex)
        {
            // Handle IO errors (e.g., disk I/O errors)
            Console.WriteLine("IO Exception: " + ex.Message);
        }
        catch (Exception ex)
        {
            // Handle other errors
            Console.WriteLine("Error" + ex.Message);
        }
    }
}

using IronPdf;
using System;
class Program
{
    static void Main(string[] args)
    {
        License.LicenseKey = "License-Key";
        var renderer = new ChromePdfRenderer();
        try
        {
            // Convert HTML to PDF
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1>");
            pdf.SaveAs("Exceptions.pdf");
            Console.WriteLine("PDF successfully created.");
        }
        catch (IronPdf.Exceptions.IronPdfProductException ex)
        {
            // Handle PDF generation errors
            Console.WriteLine("Failed to generate PDF: " + ex.Message);
        }
        catch (System.IO.IOException ex)
        {
            // Handle IO errors (e.g., disk I/O errors)
            Console.WriteLine("IO Exception: " + ex.Message);
        }
        catch (Exception ex)
        {
            // Handle other errors
            Console.WriteLine("Error" + ex.Message);
        }
    }
}

Imports IronPdf
Imports System
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		Dim renderer = New ChromePdfRenderer()
		Try
			' Convert HTML to PDF
			Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1>")
			pdf.SaveAs("Exceptions.pdf")
			Console.WriteLine("PDF successfully created.")
		Catch ex As IronPdf.Exceptions.IronPdfProductException
			' Handle PDF generation errors
			Console.WriteLine("Failed to generate PDF: " & ex.Message)
		Catch ex As System.IO.IOException
			' Handle IO errors (e.g., disk I/O errors)
			Console.WriteLine("IO Exception: " & ex.Message)
		Catch ex As Exception
			' Handle other errors
			Console.WriteLine("Error" & ex.Message)
		End Try
	End Sub
End Class

Wenn wir diesen Code ausführen, wird diese Meldung in der Befehlszeile angezeigt.

Und das ist die PDF-Datei, die mit diesem Code erzeugt wird:

Testen Sie dies in einer Umgebung, in der IronPDF richtig konfiguriert ist, und ändern Sie den HTML-Inhalt nach Bedarf für Ihre Anwendung. So können Sie Fehler effizient verwalten und die Zuverlässigkeit Ihrer PDF-Erstellungsaufgaben verbessern.

Schlussfolgerung

Die Behandlung mehrerer Ausnahmen in C# ist eine leistungsstarke Funktion, die robuste Fehlerbehandlungsmöglichkeiten in Ihren Anwendungen bietet. Durch die Verwendung mehrerer catch-Blöcke, Ausnahmefilter und des finally-Blocks können Sie eine belastbare und stabile Anwendung erstellen, die verschiedene Fehler anständig behandelt und ihre Integrität unter verschiedenen Fehlerbedingungen beibehält.

Dieses umfassende Verständnis und die Implementierung der Behandlung von Mehrfachausnahmen stellen sicher, dass Ihre Anwendungen gut vorbereitet sind, um unerwartete Situationen effektiv zu bewältigen. IronPDF bietet eine kostenloser Test beginnt mit $749.