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

Quelles sont les Exceptions, et Pourquoi les Gérer ?

En C#, une exception représente un événement qui survient pendant l'exécution d'un programme, perturbant la progression normale de l'exécution des instructions du programme. Lorsqu'une exception se produit, le flux du programme est détourné, et si l'exception n'est pas gérée, le programme se termine brutalement.

La gestion des exceptions est un moyen de prévoir et de gérer ces événements perturbateurs, permettant à votre programme de se rétablir face aux 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 gracieusement les erreurs et fournit aux utilisateurs des retours pertinents.

Le Bloc Try

Un bloc try est un segment de code que vous pensez susceptible de générer des exceptions. Lorsque vous enveloppez votre code dans un bloc try, vous indiquez au compilateur que vous souhaitez gérer les exceptions potentielles qui pourraient survenir dans ce bloc.

Voici un exemple de base sur la façon d'utiliser un bloc try :

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 Capturant des Exceptions

La déclaration catch est utilisée de concert 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 capturer une exception, vous devez créer un bloc catch immédiatement après le bloc try. Un bloc catch inclut généralement un paramètre représentant l'exception capturée.

Voici un exemple d'une déclaration 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érera une DivideByZeroException. Le bloc catch gère ensuite l'exception, affichant un message à l'utilisateur.

Blocs Catch Multiples Gérant Différentes Exceptions

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

L'exemple suivant démontre l'utilisation de plusieurs blocs catch :

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

Try
	Dim numbers(6) As Integer
	numbers(12) = 70 ' This line will throw an exception
Catch ex As IndexOutOfRangeException
	Console.WriteLine("An index out of range error occurred: " & ex.Message)
Catch e As Exception
	Console.WriteLine("An unexpected error occurred: " & e.Message)
End Try

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

Souvenez-vous, lorsque vous utilisez plusieurs blocs catch, ordonnez-les toujours des types d'exceptions les plus spécifiques aux plus générales.

Filtres d'Exception Ajoutant des Conditions aux Blocs Catch

Les filtres d'exception vous permettent d'ajouter des conditions aux blocs catch, vous permettant de capturer des exceptions uniquement si une certaine condition est remplie. Pour utiliser un filtre d'exception, ajoutez le mot-clé when suivi d'une condition dans votre déclaration catch.

L'exemple suivant démontre l'utilisation de 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 gérera la DivideByZeroException uniquement si le message de l'exception contient le mot "divide". Si la condition n'est pas remplie, le second bloc catch gérera l'exception.

Le Bloc Finally Assure l'Exécution du Code

Dans certains cas, vous pourriez vouloir vous assurer qu'une section de code particulière est exécutée, 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 survienne 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 dans le bloc try ne génère pas d'exception, le bloc finally sera toujours exécuté.

Exceptions Personnalisées : Adapter les Exceptions à Vos Besoins

Parfois, vous pourriez vouloir 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

Désormais, vous pouvez 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 de CustomException, qui est ensuite capturée et traité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 pour créer, éditer, et extraire le contenu des fichiers PDF en C#. Dans cette section, nous explorerons comment vous pouvez intégrer IronPDF avec votre approche de gestion d'exceptions try-catch pour gérer les erreurs potentielles de manière élégante.

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

Imports IronPdf
Imports System

Try
	Dim renderer = New 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

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