Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. C# Catch Multiple Exceptions
.NET AIDE

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

Curtis Chau
Curtis Chau
Mis à jour:

Gérer les exceptions correctement est essentiel en C#. Ce tutoriel vous montre comment utiliser un bloc try-catch avec plusieurs clauses catch. Nous aborderons comment attraper plusieurs types d'exceptions, utiliser des filtres d'exceptions, et s'assurer que les ressources sont nettoyées avec finalité. L'objectif est de vous aider à construire des applications C# robustes et tolérantes aux erreurs.

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

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

Qu'est-ce que la gestion des exceptions ?

La gestion des exceptions en C# est une méthode utilisée pour gérer les erreurs d'exécution, prévenir la fin abrupte d'un programme, et gérer les situations imprévues lorsqu'elles se produisent pendant l'exécution d'un programme. Les composants de base de la gestion des exceptions incluent les blocs try, catch et finally.

Structure de base du bloc Try-Catch en C

Le bloc try inclut du code qui pourrait potentiellement déclencher une exception, tandis que le bloc catch est responsable de gérer l'exception si elle se présente. Le bloc finally est optionnel et exécute du code après les blocs try et catch, que l'exception soit ou non levée. 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
$vbLabelText   $csharpLabel

Capter plusieurs exceptions

Dans les applications du monde réel, une seule opération pourrait lever des exceptions de divers types. Pour résoudre cela, 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 gérer toutes les exceptions.

Pourquoi attraper plusieurs exceptions ?

Attraper plusieurs exceptions est essentiel pour une gestion détaillée des erreurs, où les actions dépendent de l'erreur spécifique qui s'est produite. Cela permet aux développeurs de gérer chaque exception de manière appropriée dans le contexte de cette erreur particulière.

Comment implémenter plusieurs blocs catch

Voici un exemple d'implémentation d'un bloc catch unique pour attraper 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
$vbLabelText   $csharpLabel

Dans ce code, des exceptions spécifiques comme IndexOutOfRangeException et DivideByZeroException sont capturées par leurs blocs catch respectifs. Tout autre type d'exceptions est capturé par le bloc catch générique Exception.

Utiliser les filtres d'exception avec le mot-clé When

C# supporte également les filtres d'exception qui vous permettent de spécifier une condition dans le bloc catch. Cette fonctionnalité utilise le mot-clé when pour offrir plus de contrôle sur quelles exceptions attraper basées sur la condition évaluée à l'exécution.

Voici comment 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
$vbLabelText   $csharpLabel

Le rôle du bloc Finally

Le bloc finally sert à exécuter du code après que les blocs try et catch soient terminés. Il est utile pour nettoyer les ressources, comme fermer les flux de fichiers ou les connexions à la base de données, indépendamment du fait qu'une exception soit survenue.

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
$vbLabelText   $csharpLabel

Introduction de IronPDF

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

Vous pouvez effectuer n'importe quelle opération PDF sans utiliser ni installer Adobe Acrobat. IronPDF supporte diverses fonctionnalités PDF telles que l'édition, la fusion, la division et la sécurisation de documents PDF avec un cryptage et des signatures numériques. Les développeurs peuvent utiliser IronPDF dans plusieurs types d'applications, y compris les applications web, de bureau et les services.

Interconnexion :

La fonctionnalité clé d'IronPDF est la conversion de HTML en PDF, qui conserve à la fois la mise en page et le style. Elle est parfaite pour produire des PDFs à partir de contenu web, que ce soit pour des rapports, des factures ou des documentations. 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
$vbLabelText   $csharpLabel

Exemple de code

Voici un simple exemple en C# utilisant IronPDF pour créer un PDF à partir de HTML, avec une gestion des erreurs pour plusieurs types d'exceptions. Cet exemple suppose que vous avez installé IronPDF 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)
    {
        // Set your IronPDF license key, if applicable.
        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)
    {
        // Set your IronPDF license key, if applicable.
        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)
		' Set your IronPDF license key, if applicable.
		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
$vbLabelText   $csharpLabel

Lorsque nous exécutons ce code, ce message apparaît dans la ligne de commande.

C# Catch Multiple Exceptions (How It Works For Developers): Figure 1

Et c'est le fichier PDF généré par ce code :

C# Catch Multiple Exceptions (How It Works For Developers): Figure 2

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

Conclusion

C# Catch Multiple Exceptions (How It Works For Developers): Figure 3

Gérer plusieurs exceptions en C# est une fonctionnalité puissante qui offre des capacités robustes de gestion 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 gracieusement différentes erreurs et maintient son intégrité sous diverses conditions d'erreur.

Cette compréhension et implémentation complètes de la gestion de multiples exceptions garantissent que vos applications sont bien préparées à faire face efficacement aux situations imprévues. IronPDF offre un essai gratuit commence à partir de $799.

Questions Fréquemment Posées

Quelles sont certaines techniques avancées pour gérer les exceptions en C# ?

Les techniques avancées pour la gestion des exceptions en C# comprennent l'utilisation de plusieurs blocs catch pour traiter différents types d'exceptions, l'application de filtres d'exception avec le mot-clé when, et l'utilisation du bloc finally pour garantir le nettoyage des ressources. Ces techniques aident à construire des applications robustes et tolérantes aux erreurs.

Comment pouvez-vous gérer plusieurs exceptions dans une application C# ?

Vous pouvez gérer plusieurs exceptions dans une application C# en utilisant plusieurs blocs catch. Chaque bloc catch est conçu pour traiter un type spécifique d'exception, permettant des réponses personnalisées à divers scénarios d'erreur.

Que sont les filtres d'exception et comment fonctionnent-ils ?

Les filtres d'exception sont des conditions spécifiées dans un bloc catch en utilisant le mot-clé when. Ils permettent aux développeurs de capturer des exceptions basées sur des conditions d'exécution spécifiques, offrant un contrôle plus précis de la gestion des erreurs.

Comment IronPDF peut-il aider à gérer les exceptions dans la génération de PDF ?

IronPDF peut être intégré dans des projets C# pour aider à la génération de PDF tout en permettant aux développeurs d'utiliser des blocs try-catch pour gérer les erreurs pouvant survenir pendant le processus de création de PDF. Cette intégration aide à garantir des opérations tolérantes aux erreurs dans les applications.

Pourquoi est-il important de gérer les ressources avec un bloc finally en C# ?

Le bloc finally est crucial pour la gestion des ressources telles que les flux de fichiers ou les connexions à des bases de données, car il exécute du code après les blocs try et catch que l'exception soit levée ou non. Il assure que les ressources sont correctement libérées et nettoyées.

Les bibliothèques C# peuvent-elles être utilisées pour générer des PDF sans recourir à des applications tierces ?

Oui, des bibliothèques comme IronPDF permettent la génération de PDF directement au sein des applications C# sans avoir besoin d'applications tierces comme Adobe Acrobat. Ces bibliothèques fournissent des fonctionnalités pour convertir, éditer et gérer des documents PDF.

Quelle est l'importance d'utiliser plusieurs blocs catch dans la gestion des erreurs ?

L'utilisation de plusieurs blocs catch dans la gestion des erreurs permet aux développeurs de traiter différemment les types d'exceptions, améliorant la spécificité et l'efficacité des réponses aux erreurs et rendant l'application plus résiliente face à diverses conditions d'erreur.

Comment les développeurs peuvent-ils améliorer la fiabilité de leurs projets C# ?

Les développeurs peuvent améliorer la fiabilité de leurs projets C# en mettant en œuvre des stratégies complètes de gestion des exceptions, telles que l'utilisation de plusieurs blocs catch, de filtres d'exception, et de blocs finally, en particulier lorsqu'ils traitent des tâches complexes telles que la génération de PDF.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit