Try/Catch en C# (Comment ça marche pour les développeurs)

Si vous êtes novice en matière de programmation en C#, vous avez peut-être entendu parler de l'instruction "try catch". Dans ce tutoriel, nous allons nous plonger dans le monde de la gestion des exceptions, en nous concentrant sur les blocs catch, et explorer comment vous pouvez utiliser les instructions try et catch pour rendre votre code plus résistant aux erreurs. En cours de route, nous fournirons de nombreux exemples de la vie réelle pour vous aider à consolider votre compréhension.

Qu'est-ce qu'une exception et pourquoi la gérer ?

En C#, une exception représente un événement qui se produit pendant l'exécution d'un programme et qui interfère avec la progression normale de l'exécution des instructions. Lorsqu'une exception se produit, le flux du programme est détourné et, si l'exception n'est pas gérée, le programme s'arrête brusquement.

La gestion des exceptions est un moyen d'anticiper et de gérer ces événements perturbateurs, ce qui permet à votre programme de se remettre des problèmes inattendus et de continuer à fonctionner comme prévu. En utilisant les blocs try et catch, vous pouvez vous assurer que votre code gère les erreurs de manière gracieuse et fournit aux utilisateurs un retour d'information significatif.

Le bloc d'essai

Un bloc d'essai est un segment de code dont on s'attend à ce qu'il génère des exceptions. Lorsque vous intégrez votre code dans un bloc try, vous indiquez au compilateur que vous souhaitez gérer les exceptions potentielles qui peuvent survenir dans ce bloc.

Voici un exemple de base de l'utilisation d'un bloc d'essai :

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

Bloc Catch Rattrapage des exceptions

L'instruction catch est utilisée en conjonction avec un bloc try pour gérer les exceptions. Lorsqu'une exception se produit dans un bloc try, l'exécution du programme passe au bloc catch approprié, où vous pouvez spécifier ce que le programme doit faire en réponse à l'exception.

Pour rattraper une exception, vous devez créer un bloc catch immédiatement après le bloc try. Un bloc catch comprend généralement un paramètre qui représente l'exception capturée.

Voici un exemple d'instruction catch en action :

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

Dans cet exemple, le code à l'intérieur du bloc try tente de diviser par zéro, ce qui génère une DivideByZeroException. Le bloc catch gère ensuite l'exception en affichant un message à l'intention de l'utilisateur.

Blocs de capture multiples gérant des exceptions différentes

Parfois, votre bloc d'essai peut générer différents types d'exceptions possibles. Dans ce cas, vous pouvez utiliser plusieurs blocs catch pour traiter chaque type d'exception séparément.

L'exemple suivant illustre l'utilisation de plusieurs blocs catch :

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

Dans cet exemple, le code à l'intérieur du bloc try tente d'assigner une valeur à un index de tableau qui n'existe pas, ce qui génère une exception IndexOutOfRangeException. Le premier bloc catch gère cette exception spécifique, tandis que le second bloc catch capture toute autre exception susceptible de se produire.

N'oubliez pas que lorsque vous utilisez plusieurs blocs catch, vous devez toujours les classer du plus spécifique au plus général des types d'exception.

Filtres d'exception Ajout de conditions aux blocs de capture

Les filtres d'exception vous permettent d'ajouter des conditions aux blocs de capture, ce qui vous permet de ne capturer les exceptions que si une certaine condition est remplie. Pour utiliser un filtre d'exception, ajoutez le mot-clé when suivi d'une condition dans votre instruction catch.

L'exemple suivant illustre l'utilisation des filtres d'exception :

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

Dans l'exemple ci-dessus, le premier bloc catch ne traitera l'exception DivideByZeroException que si le message d'exception contient le mot "divide". Si la condition n'est pas remplie, le deuxième bloc catch traitera l'exception.

Le bloc Finally garantit l'exécution du code

Dans certains cas, vous pouvez vouloir vous assurer qu'un morceau de code particulier est exécuté, qu'une exception se produise ou non. Pour ce faire, vous pouvez utiliser un bloc finally.

Un bloc finally est placé après les blocs try et catch et est toujours exécuté, qu'une exception se produise ou non.

Voici un exemple qui démontre l'utilisation d'un bloc finally :

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

Dans l'exemple ci-dessus, même si le code à l'intérieur du bloc try ne génère pas d'exception, le bloc finally sera quand même exécuté.

Exceptions personnalisées : Adapter les exceptions à vos besoins

Il peut arriver que vous souhaitiez créer vos propres exceptions personnalisées pour gérer des exceptions spécifiques dans votre code. Pour ce faire, vous pouvez créer une nouvelle classe qui hérite de la classe Exception.

Voici un exemple de création d'une exception personnalisée :

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

Vous pouvez maintenant utiliser cette exception personnalisée dans vos blocs try et catch, comme ceci :

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

Dans cet exemple, le bloc try lance une instance CustomException, qui est ensuite capturée et gérée par le bloc catch.

IronPDF : Intégration de la fonctionnalité PDF avec la gestion des exceptions

En savoir plus sur IronPDF est une bibliothèque populaire permettant de créer, d'éditer et d'extraire du contenu de fichiers PDF en C#. Dans cette section, nous allons voir comment vous pouvez intégrer IronPDF à votre approche de gestion des exceptions try-catch afin de gérer les erreurs potentielles de manière élégante.

Installation d'IronPDF

Pour commencer, vous devez d'abord installer le paquet NuGet IronPDF. Vous pouvez le faire à l'aide de la console du gestionnaire de paquets :

Install-Package IronPdf

Vous pouvez également rechercher "IronPDF" dans la boîte de dialogue "Manage NuGet Packages" de Visual Studio.

Création d'un PDF avec IronPDF et gestion des exceptions

Supposons que vous souhaitiezcréer un fichier PDF à partir d'une chaîne HTML avec IronPDF. Comme le processus de création d'un PDF peut potentiellement soulever des exceptions, vous pouvez utiliser des blocs try-catch pour les gérer. Voici un exemple de la façon dont vous pouvez créer un PDF en utilisant IronPDF et gérer les exceptions avec try-catch :

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

Dans cet exemple, le bloc try contient le code permettant de créer un PDF à l'aide d'IronPDF. Si une exception se produit au cours du processus, les blocs de capture gèrent l'erreur et affichent un message d'erreur approprié à l'utilisateur.

Extraction de texte à partir d'un PDF et traitement des exceptions

Vous pouvez également extraire du texte d'un fichier PDF à l'aide d'IronPDF. Comme dans l'exemple précédent, vous pouvez utiliser des blocs try-catch pour gérer les exceptions potentielles.

Voici un exemple d'extraction de texte à partir d'un fichier PDF à l'aide d'IronPDF et de traitement des exceptions :

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

Dans cet exemple, le bloc try contient le code permettant d'extraire le texte d'un PDF à l'aide d'IronPDF. Si une exception se produit au cours du processus, les blocs de capture gèrent l'erreur et affichent un message approprié à l'utilisateur.

Conclusion

En combinantIronPDF avec votre approche de gestion des exceptions try-catch, vous pouvez créer des applications robustes qui gèrent gracieusement les erreurs lorsque vous travaillez avec des fichiers PDF. Cela permet non seulement d'améliorer la stabilité de vos applications, mais aussi d'améliorer l'expérience globale de l'utilisateur.

N'oubliez pas de toujours prendre en compte les exceptions potentielles lorsque vous travaillez avec des bibliothèques externes comme IronPDF, et de les traiter de manière appropriée en utilisant des instructions try et catch. Vous pouvez ainsi vous assurer que vos applications sont résistantes et conviviales, même en cas de problèmes inattendus.

IronPDF offre un service deessai gratuit de sa bibliothèquevous pouvez ainsi explorer ses capacités sans aucun engagement de votre part. Si vous décidez de continuer à utiliser IronPDF après la période d'essai, la licence commence à partir de $749.