C# Catch Multiple Exceptions (Comment ça marche pour les développeurs)

Traitement des exceptions correctement est essentiel en C#. Ce tutoriel vous montre comment utiliser un bloc try-catch avec plusieurs clauses catch. Nous verrons comment attraper plusieurs types d'exceptions, utiliser des filtres d'exceptions et nous assurer que les ressources sont nettoyées de manière définitive. L'objectif est de vous aider à créer des applications C# robustes et tolérantes aux erreurs.

En apprenant à détecter plusieurs types d'exceptions, vous pouvez adapter les réponses à des problèmes spécifiques, ce qui améliore la fiabilité de votre programme. Nous verrons également comment appliquer des conditions aux blocs catch avec le mot-clé when, ce qui permet une gestion plus précise des erreurs.

Ce guide vous donnera les méthodes pour attraper les exceptions et gérer les erreurs courantes et complexes en douceur dans vos projets de codage. Nous explorerons également IronPDF dans le cadre de la gestion des exceptions.

Qu'est-ce que la gestion des exceptions ?

Le traitement des exceptions en C# est une méthode utilisée pour gérer les erreurs d'exécution, empêcher l'arrêt brutal d'un programme et gérer les situations inattendues lorsqu'elles surviennent au cours de l'exécution d'un programme. Les composants essentiels de la gestion des exceptions sont les blocs try, catch et finally.

Structure de base de Try-Catch dans C# ;

Le bloc try inclut le code susceptible de déclencher une exception, tandis que le bloc catch est chargé de gérer l'exception si elle se produit. Le bloc finally est optionnel et exécute le code après les blocs try et catch, qu'une exception ait été levée ou non. Voici une structure simple :

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

Rattraper des exceptions multiples

Dans les applications réelles, une seule opération peut générer des exceptions de différents types. Pour y remédier, C# vous permet de définir plusieurs blocs catch pour un seul bloc try. Chaque bloc catch peut spécifier un type d'exception différent pour traiter toutes les exceptions.

Pourquoi attraper des exceptions multiples ?

La capture d'exceptions multiples est essentielle pour la gestion détaillée des erreurs, où les actions dépendent de l'erreur spécifique qui s'est produite. Il permet aux développeurs de traiter chaque exception d'une manière adaptée au contexte de l'erreur en question.

Comment mettre en œuvre des blocs de capture multiples

Voici un exemple de mise en œuvre d'un bloc de capture unique pour capturer plusieurs types d'exceptions :

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

Dans ce code, des exceptions spécifiques comme IndexOutOfRangeException et DivideByZeroException sont capturées par leurs blocs catch respectifs. Tous les autres types d'exceptions sont capturés par le bloc de capture générique Exception.

Utilisation de filtres d'exception avec le mot-clé When

C# prend également en charge les filtres d'exception qui vous permettent de spécifier une condition dans le bloc catch. Cette fonctionnalité utilise le mot-clé when pour fournir plus de contrôle sur les exceptions à attraper en fonction de la condition évaluée au moment de l'exécution.

Voici comment vous pouvez utiliser le mot-clé when pour ajouter des filtres d'exception :

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

Le rôle du bloc final

Le bloc finally est utilisé pour exécuter le code après que les blocs try et catch soient terminés. Elle est utile pour nettoyer les ressources, comme fermer les flux de fichiers ou les connexions aux bases de données, qu'une exception se soit produite ou non.

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

Présentation d'IronPDF

IronPDF est une bibliothèque complète conçue pour les développeurs C# travaillant dans les applications .NET. Il aide les développeurs à manipuler, gérer et créer des fichiers PDF directement à partir de HTML. Il ne nécessite pas de dépendance externe pour fonctionner.

Vous pouvez effectuer n'importe quelle opération PDF sans utiliser et installer Adobe Acrobat. IronPDF prend en charge diverses fonctionnalités PDF telles que l'édition, la fusion, le fractionnement et la sécurisation des documents PDF à l'aide du cryptage et des signatures numériques. Les développeurs peuvent utiliser IronPDF dans de nombreux types d'applications, y compris les applications Web, les applications de bureau et les services.

Interlink

La fonctionnalité clé d'IronPDF est la conversion HTML vers PDF, qui conserve à la fois la mise en page et le style. C'est parfait pour produire des PDF à partir de contenu web, que ce soit pour des rapports, des factures ou de la documentation. Les fichiers HTML, les URL et les chaînes HTML peuvent tous être convertis en fichiers 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");
    }
}

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

Exemple de code

Voici un exemple C# simple utilisant IronPDF pour créer un PDF à partir de HTML, avec une gestion des erreurs pour plusieurs types d'exceptions. Cet exemple suppose qu'IronPDF est installé dans votre projet. Exécutez cette commande dans la console NuGet pour installer IronPDF :

Install-Package IronPdf

Voici le 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

Lorsque nous exécutons ce code, il affiche ce message dans la ligne de commande.

Il s'agit du fichier PDF généré par ce code :

Veillez à tester ceci dans un environnement où IronPDF est correctement configuré, et modifiez le contenu HTML selon les besoins de votre application. Cela vous aidera à gérer efficacement les erreurs et à améliorer la fiabilité de vos tâches de génération de PDF.

Conclusion

La gestion d'exceptions multiples en C# est une fonctionnalité puissante qui offre de solides capacités de traitement des erreurs dans vos applications. En utilisant plusieurs blocs catch, des filtres d'exception et le bloc finally, vous pouvez créer une application résiliente et stable qui gère différentes erreurs de manière gracieuse et maintient son intégrité dans diverses conditions d'erreur.

Cette compréhension globale et la mise en œuvre de la gestion des exceptions multiples garantissent que vos applications sont bien préparées pour faire face à des situations inattendues de manière efficace. IronPDF offre un service de essai gratuit commence à partir de $749.