C# try catch finally (Comment ça fonctionne pour les développeurs)

En C#, le bloc try-catch vous permet de gérer les exceptions qui se produisent lors de l'exécution de votre code. La section du bloc try contient le code qui pourrait lancer une exception, tandis que le bloc catch gère l'exception si elle se produit. Cette structure est essentielle pour prévenir les plantages d'application en gérant gracieusement les exceptions, évitant de les laisser se propager dans la pile d'appels.

Le bloc try est l'endroit où vous placez tout code pouvant potentiellement lancer une exception. Ce bloc sert de garde-fou, vous permettant de spécifier une section de code qui doit être surveillée pour les erreurs. Si des parties du bloc try lancent des exceptions, le contrôle est immédiatement transféré au bloc catch correspondant.

Le bloc catch suit le bloc try et est utilisé pour gérer les exceptions lancées par le code du bloc try. Vous pouvez avoir plusieurs blocs catch configurés pour gérer différents types d'exceptions potentiels séparément. Chaque bloc catch spécifie le type d'exception qu'il gère et contient le code pour traiter l'exception, tel que la journalisation de l'erreur ou l'affichage d'un message convivial à propos de l'erreur.

using IronPdf;
public static void Main(string[] args)
{
    try
    {
        // Create a PDF renderer using Chrome.
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        // Render an HTML file as a PDF.
        var pdf = renderer.RenderHtmlFileAsPdf("Example.html");
        // Save the PDF to the specified file path.
        pdf.SaveAs("output.pdf");
    }
    catch (FileNotFoundException ex)
    {
        // Handle file not found exception
        Console.WriteLine("File not found: " + ex.Message);
    }
    catch (UnauthorizedAccessException ex)
    {
        // Handle unauthorized access exception
        Console.WriteLine("Error: Access to the file is denied. " + ex.Message);
    }
    catch (Exception ex)
    {
        // Handle any other exceptions
        Console.WriteLine("An unexpected error occurred: " + ex.Message);
    }
}

using IronPdf;
public static void Main(string[] args)
{
    try
    {
        // Create a PDF renderer using Chrome.
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        // Render an HTML file as a PDF.
        var pdf = renderer.RenderHtmlFileAsPdf("Example.html");
        // Save the PDF to the specified file path.
        pdf.SaveAs("output.pdf");
    }
    catch (FileNotFoundException ex)
    {
        // Handle file not found exception
        Console.WriteLine("File not found: " + ex.Message);
    }
    catch (UnauthorizedAccessException ex)
    {
        // Handle unauthorized access exception
        Console.WriteLine("Error: Access to the file is denied. " + ex.Message);
    }
    catch (Exception ex)
    {
        // Handle any other exceptions
        Console.WriteLine("An unexpected error occurred: " + ex.Message);
    }
}

Imports IronPdf
Public Shared Sub Main(ByVal args() As String)
	Try
		' Create a PDF renderer using Chrome.
		Dim renderer As New ChromePdfRenderer()
		' Render an HTML file as a PDF.
		Dim pdf = renderer.RenderHtmlFileAsPdf("Example.html")
		' Save the PDF to the specified file path.
		pdf.SaveAs("output.pdf")
	Catch ex As FileNotFoundException
		' Handle file not found exception
		Console.WriteLine("File not found: " & ex.Message)
	Catch ex As UnauthorizedAccessException
		' Handle unauthorized access exception
		Console.WriteLine("Error: Access to the file is denied. " & ex.Message)
	Catch ex As Exception
		' Handle any other exceptions
		Console.WriteLine("An unexpected error occurred: " & ex.Message)
	End Try
End Sub

Exemple d'une FileNotFoundException

Lorsqu'on travaille avec IronPDF pour générer des PDFs, il est crucial d'anticiper et de gérer les différentes exceptions qui pourraient survenir au cours du processus. Une implémentation correcte du code de gestion des exceptions non seulement empêche votre application de planter, mais fournit également un moyen de répondre gracieusement aux erreurs, améliorant ainsi la robustesse globale et l'expérience utilisateur de votre application. Certaines exceptions communes qui peuvent être lancées incluent :

• FileNotFoundException : Cette exception se produit lorsque vous essayez de charger un fichier avec IronPDF qui n'existe pas sur le chemin de fichier spécifié. Une façon de gérer cela pourrait être d'utiliser File.Exists(path) pour vérifier l'existence du fichier ou d'encapsuler l'opération dans un bloc d'instruction if pour vérifier si le fichier existe.
• InvalidOperationException : Cela se produit lorsque l'état du document PDF est invalide pour l'opération en cours. Par exemple, si vous essayez de réaliser des opérations sur un PDF qui n'est pas entièrement chargé ou rendu.
• UnauthorizedAccessException : Cette exception se produit lorsque l'application n'a pas la permission d'accéder au fichier ou au répertoire spécifié. Cela peut arriver en raison de permissions de fichier restrictives ou en essayant d'écrire dans un fichier en lecture-seule. Par exemple, si vous essayiez d'écrire des fichiers PDF de sortie dans un répertoire où l'application n'a pas les permissions d'écriture.

Certaines classes d'exception spécifiques à IronPDF incluent :

• IronPdfAssemblyVersionMismatchException : Cela se réfère aux erreurs qui surviennent lors du chargement des assemblages pendant le déploiement de IronPDF.
• IronPdfNativeException : Cela représente les erreurs qui peuvent se produire dans le code natif de IronPDF.
• IronPdfProductException : Cela représente toutes les erreurs qui peuvent survenir lors de l'exécution d'IronPDF.

using IronPdf;
using IronPdf.Exceptions;
public static void Main(string[] args)
{
    try
    {
        // Set the IronPDF license key
        IronPdf.License.LicenseKey = "license-key";
        // Create a PDF renderer
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        // Generate PDF from HTML
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1>");
        // Save the PDF
        pdf.SaveAs("output.pdf");
    }
    catch (IronPdfProductException ex)
    {
        // Handle PDF generation specific exceptions
        Console.WriteLine("Error During IronPDF execution: " + ex.Message);
    }
    catch (Exception ex)
    {
        // Handle general exceptions
        Console.WriteLine("An unexpected error occurred: " + ex.Message);
    }
}

using IronPdf;
using IronPdf.Exceptions;
public static void Main(string[] args)
{
    try
    {
        // Set the IronPDF license key
        IronPdf.License.LicenseKey = "license-key";
        // Create a PDF renderer
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        // Generate PDF from HTML
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1>");
        // Save the PDF
        pdf.SaveAs("output.pdf");
    }
    catch (IronPdfProductException ex)
    {
        // Handle PDF generation specific exceptions
        Console.WriteLine("Error During IronPDF execution: " + ex.Message);
    }
    catch (Exception ex)
    {
        // Handle general exceptions
        Console.WriteLine("An unexpected error occurred: " + ex.Message);
    }
}

Imports IronPdf
Imports IronPdf.Exceptions
Public Shared Sub Main(ByVal args() As String)
	Try
		' Set the IronPDF license key
		IronPdf.License.LicenseKey = "license-key"
		' Create a PDF renderer
		Dim renderer As New ChromePdfRenderer()
		' Generate PDF from HTML
		Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1>")
		' Save the PDF
		pdf.SaveAs("output.pdf")
	Catch ex As IronPdfProductException
		' Handle PDF generation specific exceptions
		Console.WriteLine("Error During IronPDF execution: " & ex.Message)
	Catch ex As Exception
		' Handle general exceptions
		Console.WriteLine("An unexpected error occurred: " & ex.Message)
	End Try
End Sub

Sortie

Un exemple de gestion des exceptions avec IronPDF pourrait être que la clé de licence est incorrecte ou manquante. Dans ce cas, IronPdfProductException, si elle est utilisée dans le cadre du processus de gestion des exceptions, serait utilisée pour afficher le message d'erreur correspondant.

Dans les scénarios impliquant des opérations sur fichier ou la gestion des ressources, le bloc finally garantit que toutes les ressources sont libérées de manière appropriée, même si une erreur se produit au cours du processus.

Lorsqu'on travaille avec des fichiers, il est courant d'ouvrir un flux de fichier pour la lecture ou l'écriture. Si une exception se produit lors du traitement du fichier, ne pas fermer le flux pourrait laisser le fichier verrouillé ou causer d'autres problèmes. Le bloc finally garantit que le flux de fichier est toujours fermé, libérant ainsi la ressource.

public static void Main(string[] args)
{
    FileStream fileStream = null;
    try
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        // Generate PDF from HTML
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1>");
        pdf.SaveAs("output.pdf");
        pdfGenerated = true;
    }
    catch (IronPdf.Exceptions.IronPdfProductException ex)
    {
        // Handle PDF generation specific exceptions
        Console.WriteLine("Error During IronPDF execution: " + ex.Message);
    }
    catch (Exception ex)
    {
        // Handle general exceptions to avoid any unhandled exception issues
        Console.WriteLine("An unexpected error occurred: " + ex.Message);
    }
    finally
    {
        // Cleanup resources if necessary
        if (fileStream != null)
        {
            fileStream.Close();
            fileStream.Dispose();
        }
    }
}

public static void Main(string[] args)
{
    FileStream fileStream = null;
    try
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        // Generate PDF from HTML
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1>");
        pdf.SaveAs("output.pdf");
        pdfGenerated = true;
    }
    catch (IronPdf.Exceptions.IronPdfProductException ex)
    {
        // Handle PDF generation specific exceptions
        Console.WriteLine("Error During IronPDF execution: " + ex.Message);
    }
    catch (Exception ex)
    {
        // Handle general exceptions to avoid any unhandled exception issues
        Console.WriteLine("An unexpected error occurred: " + ex.Message);
    }
    finally
    {
        // Cleanup resources if necessary
        if (fileStream != null)
        {
            fileStream.Close();
            fileStream.Dispose();
        }
    }
}

Public Shared Sub Main(ByVal args() As String)
	Dim fileStream As FileStream = Nothing
	Try
		Dim renderer As New ChromePdfRenderer()
		' Generate PDF from HTML
		Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1>")
		pdf.SaveAs("output.pdf")
		pdfGenerated = True
	Catch ex As IronPdf.Exceptions.IronPdfProductException
		' Handle PDF generation specific exceptions
		Console.WriteLine("Error During IronPDF execution: " & ex.Message)
	Catch ex As Exception
		' Handle general exceptions to avoid any unhandled exception issues
		Console.WriteLine("An unexpected error occurred: " & ex.Message)
	Finally
		' Cleanup resources if necessary
		If fileStream IsNot Nothing Then
			fileStream.Close()
			fileStream.Dispose()
		End If
	End Try
End Sub

Sortie de l'Exécution du Bloc Finally

Lorsqu'on traite des opérations sur fichier dans IronPDF, gérer les exceptions comme FileNotFoundException et UnauthorizedAccessException est crucial. Ces exceptions surviennent souvent lorsque les fichiers manquent ou que les permissions sont restreintes. Gérer correctement ces exceptions est essentiel pour maintenir la robustesse et la fiabilité de votre application, car elles surviennent souvent lorsqu'il y a des problèmes avec les chemins de fichiers, la disponibilité ou les permissions d'accès.

using IronPdf;
using System.IO;
using IronPdf.Exceptions;
public static void Main(string[] args)
{
    try
    {
        // Generate PDF from an RTF file
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderRtfFileAsPdf("filePath");
        pdf.SaveAs("output.pdf");
    }
    catch (IronPdf.Exceptions.IronPdfProductException ex)
    {
        // Handle PDF generation specific exceptions
        Console.WriteLine("Error During IronPDF execution: " + ex.Message);
    }
    catch (IOException ex)
    {
        int retries = 5;
        int delay = 1000; // Delay in milliseconds
        Console.WriteLine("IO Exception: " + ex.Message);
        retries--;
        if (retries > 0)
        {
            Console.WriteLine("File is in use. Retrying in " + delay + "ms...");
            System.Threading.Thread.Sleep(delay);
        }
        else
        {
            Console.WriteLine("Failed to access the file after multiple attempts.");
        }
    }
    catch (Exception ex)
    {
        // Handle general exceptions
        Console.WriteLine("An unexpected error occurred: " + ex.Message);
    }
    finally
    {
        // Delete the temporary file
        if (File.Exists("temp.txt"))
        {
            File.Delete("temp.txt");
            Console.WriteLine("Cleanup Complete!");
        }
    }
}

using IronPdf;
using System.IO;
using IronPdf.Exceptions;
public static void Main(string[] args)
{
    try
    {
        // Generate PDF from an RTF file
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderRtfFileAsPdf("filePath");
        pdf.SaveAs("output.pdf");
    }
    catch (IronPdf.Exceptions.IronPdfProductException ex)
    {
        // Handle PDF generation specific exceptions
        Console.WriteLine("Error During IronPDF execution: " + ex.Message);
    }
    catch (IOException ex)
    {
        int retries = 5;
        int delay = 1000; // Delay in milliseconds
        Console.WriteLine("IO Exception: " + ex.Message);
        retries--;
        if (retries > 0)
        {
            Console.WriteLine("File is in use. Retrying in " + delay + "ms...");
            System.Threading.Thread.Sleep(delay);
        }
        else
        {
            Console.WriteLine("Failed to access the file after multiple attempts.");
        }
    }
    catch (Exception ex)
    {
        // Handle general exceptions
        Console.WriteLine("An unexpected error occurred: " + ex.Message);
    }
    finally
    {
        // Delete the temporary file
        if (File.Exists("temp.txt"))
        {
            File.Delete("temp.txt");
            Console.WriteLine("Cleanup Complete!");
        }
    }
}

Imports IronPdf
Imports System.IO
Imports IronPdf.Exceptions
Public Shared Sub Main(ByVal args() As String)
	Try
		' Generate PDF from an RTF file
		Dim renderer As New ChromePdfRenderer()
		Dim pdf = renderer.RenderRtfFileAsPdf("filePath")
		pdf.SaveAs("output.pdf")
	Catch ex As IronPdf.Exceptions.IronPdfProductException
		' Handle PDF generation specific exceptions
		Console.WriteLine("Error During IronPDF execution: " & ex.Message)
	Catch ex As IOException
		Dim retries As Integer = 5
		Dim delay As Integer = 1000 ' Delay in milliseconds
		Console.WriteLine("IO Exception: " & ex.Message)
		retries -= 1
		If retries > 0 Then
			Console.WriteLine("File is in use. Retrying in " & delay & "ms...")
			System.Threading.Thread.Sleep(delay)
		Else
			Console.WriteLine("Failed to access the file after multiple attempts.")
		End If
	Catch ex As Exception
		' Handle general exceptions
		Console.WriteLine("An unexpected error occurred: " & ex.Message)
	Finally
		' Delete the temporary file
		If File.Exists("temp.txt") Then
			File.Delete("temp.txt")
			Console.WriteLine("Cleanup Complete!")
		End If
	End Try
End Sub

Exemple de Sortie : FileNotFound

Exemple de Sortie : IOException

Exemple de Sortie : Erreur Inattendue avec IronPdfNativeException

Journaliser les erreurs lors du traitement des PDFs est essentiel pour le débogage et la surveillance. Cela vous permet de capter des informations détaillées sur les problèmes qui se produisent, ce qui peut être inestimable pour diagnostiquer les problèmes et améliorer la fiabilité de votre application.

using IronPdf;
using IronPdf.Logging;
public static void Main(string[] args)
{
    IronPdf.Logging.Logger.LogFilePath = "Default.log";
    IronPdf.Logging.Logger.LoggingMode = IronPdf.Logging.Logger.LoggingModes.All;
    try
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlFileAsPdf("report.html");
        pdf.SaveAs("output.pdf");
    }
    catch (Exception ex)
    {
        // Log the exception
        IronSoftware.Logger.Log("PDF processing failed: " + ex.Message);
    }
    finally
    {
        Console.WriteLine("PDF processing attempt finished.");
    }
}

using IronPdf;
using IronPdf.Logging;
public static void Main(string[] args)
{
    IronPdf.Logging.Logger.LogFilePath = "Default.log";
    IronPdf.Logging.Logger.LoggingMode = IronPdf.Logging.Logger.LoggingModes.All;
    try
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlFileAsPdf("report.html");
        pdf.SaveAs("output.pdf");
    }
    catch (Exception ex)
    {
        // Log the exception
        IronSoftware.Logger.Log("PDF processing failed: " + ex.Message);
    }
    finally
    {
        Console.WriteLine("PDF processing attempt finished.");
    }
}

Imports IronPdf
Imports IronPdf.Logging
Public Shared Sub Main(ByVal args() As String)
	IronPdf.Logging.Logger.LogFilePath = "Default.log"
	IronPdf.Logging.Logger.LoggingMode = IronPdf.Logging.Logger.LoggingModes.All
	Try
		Dim renderer As New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlFileAsPdf("report.html")
		pdf.SaveAs("output.pdf")
	Catch ex As Exception
		' Log the exception
		IronSoftware.Logger.Log("PDF processing failed: " & ex.Message)
	Finally
		Console.WriteLine("PDF processing attempt finished.")
	End Try
End Sub

Sortie Console

Sortie des Logs

1. Création du Sauvegarde :

   • Le PDF est initialement enregistré dans un emplacement de sauvegarde (backupPdfPath).

2. Opération Réussie :

   • Si la génération du PDF réussit (pdfGenerated = true), le PDF de sauvegarde est déplacé vers l'emplacement de sortie final.

3. Rollback en Cas d'Échec :

   • Si une exception se produit et que pdfGenerated reste faux, le PDF de sauvegarde est supprimé dans le bloc final pour annuler toute modification partielle.
4. Nettoyage :
   • Qu'il y ait succès ou échec, le fichier temporaire est supprimé dans le bloc finally pour s'assurer qu'aucun fichier résiduel ne subsiste.

En implémentant ce mécanisme de rollback, vous vous assurez que le système de fichiers reste dans un état cohérent, même si une erreur se produit pendant le processus de génération de PDF.

Sortie