La journalisation est une technique essentielle en C# qui capture des informations, des avertissements, des erreurs et d'autres données pertinentes pendant que l'application est en cours d'exécution. Elle aide les développeurs à surveiller le comportement de leurs programmes, à résoudre les problèmes et à comprendre comment l'application fonctionne dans divers contextes. C# offre certains frameworks de journalisation et packages pour simplifier les tâches de journalisation. Microsoft.Extensions.Logging est l'un des frameworks de journalisation les plus utilisés dans les applications .NET Core. Le package NuGet Microsoft.Extensions.Logging for .NET Core nous donne accès à plusieurs méthodes d'extension pour nous aider à écrire différents niveaux de log. Cet article aborde la journalisation MS.

Comment configurer la journalisation MS

1. Créez un nouveau projet Visual Studio.
2. Installez la bibliothèque Microsoft.Extensions.Logging à partir de la page du package Microsoft.Extensions.Logging sur NuGet.
3. Injectez l'interface Logger dans la console.
4. Configurez la sortie de la journalisation.
5. Écrivez des journaux à différents niveaux.
6. Exécutez le code.

Étape 1 : Créer un nouveau projet Visual Studio

Pour commencer, créez un nouveau projet dans Visual Studio.

Étape 2 : Installer la bibliothèque Microsoft.Extensions.Logging

Installez la bibliothèque Microsoft.Extensions.Logging en utilisant la page du package Microsoft.Extensions.Logging sur NuGet. Cette bibliothèque fournit les classes et méthodes nécessaires pour la journalisation dans les applications .NET Core.

Étape 3 : Injecter l'interface Logger dans la console

Pour utiliser la fonctionnalité de journalisation, vous devez injecter une instance de l'interface ILogger dans votre application console. Cela peut être fait en utilisant une usine de journalisation.

using Microsoft.Extensions.Logging;

// Create a logger for the application
ILogger<Program> logger = LoggerFactory.Create(builder =>
{
    builder.AddConsole(); // Adding console logging
}).CreateLogger<Program>();

using Microsoft.Extensions.Logging;

// Create a logger for the application
ILogger<Program> logger = LoggerFactory.Create(builder =>
{
    builder.AddConsole(); // Adding console logging
}).CreateLogger<Program>();

Imports Microsoft.Extensions.Logging

' Create a logger for the application
Private logger As ILogger(Of Program) = LoggerFactory.Create(Sub(builder)
	builder.AddConsole() ' Adding console logging
End Sub).CreateLogger<Program>()

Imports Microsoft.Extensions.Logging

' Create a logger for the application
Private logger As ILogger(Of Program) = LoggerFactory.Create(Sub(builder)
	builder.AddConsole() ' Adding console logging
End Sub).CreateLogger<Program>()

Étape 4 : Configurer la sortie de la journalisation

Configurez comment les journaux doivent être sortis. Cela peut être fait en ajoutant un ou plusieurs fournisseurs de journalisation au constructeur de logger. Le fournisseur le plus courant est le logger console, qui sort les journaux à la console.

builder.AddConsole(options =>
{
    options.TimestampFormat = "[HH:mm:ss] "; // Setting the timestamp format for logs
});

builder.AddConsole(options =>
{
    options.TimestampFormat = "[HH:mm:ss] "; // Setting the timestamp format for logs
});

builder.AddConsole(Sub(options)
	options.TimestampFormat = "[HH:mm:ss] " ' Setting the timestamp format for logs
End Sub)

builder.AddConsole(Sub(options)
	options.TimestampFormat = "[HH:mm:ss] " ' Setting the timestamp format for logs
End Sub)

Étape 5 : Écrire des journaux à différents niveaux

Vous pouvez maintenant écrire des journaux à différents niveaux en utilisant l'objet logger. Les méthodes de journalisation disponibles sont LogDebug(), LogInformation(), LogWarning(), LogError() et LogCritical().

logger.LogDebug("This is a debug message");
logger.LogInformation("This is an information message");
logger.LogWarning("This is a warning message");
logger.LogError("This is an error message");
logger.LogCritical("This is a critical message");

logger.LogDebug("This is a debug message");
logger.LogInformation("This is an information message");
logger.LogWarning("This is a warning message");
logger.LogError("This is an error message");
logger.LogCritical("This is a critical message");

logger.LogDebug("This is a debug message")
logger.LogInformation("This is an information message")
logger.LogWarning("This is a warning message")
logger.LogError("This is an error message")
logger.LogCritical("This is a critical message")

logger.LogDebug("This is a debug message")
logger.LogInformation("This is an information message")
logger.LogWarning("This is a warning message")
logger.LogError("This is an error message")
logger.LogCritical("This is a critical message")

Étape 6 : Exécuter le code

Enfin, exécutez votre code et observez les journaux sortis selon les paramètres configurés.

Et voilà ! Vous avez configuré et utilisé avec succès la journalisation MS dans votre application C#.

Installer la journalisation MS

Pour installer la journalisation MS, suivez ces étapes :

1. Lancez Visual Studio.

2. Allez à Outils > Gestionnaire de packages NuGet > Console du gestionnaire de packages.

3. Dans la console du gestionnaire de packages, exécutez la commande suivante :

   Install-Package Microsoft.Extensions.Logging

   PowerShell

4. Appuyez sur Entrée pour exécuter la commande. Cela téléchargera et installera le package Microsoft.Extensions.Logging dans votre projet.

Niveaux de journalisation

Plusieurs niveaux de journalisation sont disponibles dans le framework Microsoft.Extensions.Logging en C#, permettant aux développeurs de classer et hiérarchiser les messages de log selon leur importance et gravité. Ces niveaux sont fréquemment utilisés pour distinguer les différents types de messages et aider à réguler la verbosité des journaux.

Les niveaux de journalisation par défaut offerts par Microsoft.Extensions.Logging sont les suivants :

• Trace : Le niveau le plus approfondi, souvent utilisé pour des données extrêmement détaillées qui offrent une compréhension approfondie du fonctionnement interne du programme.
• Débogage : Informations de débogage utiles pendant les phases de développement et de débogage, mais souvent inutiles en production.
• Information : Fournit des détails sur le fonctionnement normal de l'application. Habituellement, le fonctionnement régulier du programme est suivi à l'aide de ces journaux.
• Avertissement : Indique un problème potentiel ou un élément susceptible de nécessiter une attention particulière ultérieurement. Il est utilisé pour des situations anormales ou inattendues qui pourraient entraîner des problèmes mais qui ne causent pas nécessairement l'arrêt du programme.
• Erreur : Signale un problème grave ou une erreur qui doit être corrigée immédiatement. Habituellement utilisé pour enregistrer les problèmes qui affectent le fonctionnement de l'application.
• Critique : État le plus grave, utilisé pour enregistrer les problèmes critiques qui nécessitent une intervention immédiate car ils peuvent entraîner des problèmes sérieux ou des plantages du programme.

Chaque niveau de journalisation a une fonction spécifique et permet aux développeurs de gérer la quantité de données que le framework de journalisation produit. Les développeurs peuvent choisir le niveau approprié pour l'enregistrement des messages en fonction de la gravité et de l'importance des données enregistrées.

Configuration de la journalisation C#

Voici un exemple de base de la configuration de la journalisation avec Microsoft.Extensions.Logging :

using Microsoft.Extensions.Logging;
using System;

class Program
{
    // Create a LoggerFactory instance
    private static readonly ILoggerFactory LoggerFactory = LoggerFactory.Create(builder =>
    {
        // Add console logger
        builder.AddConsole();
        // You can add other logging providers here (e.g., AddDebug, AddFile, etc.)
    });

    // Create a logger
    private static readonly ILogger Logger = LoggerFactory.CreateLogger<Program>();

    static void Main(string[] args)
    {
        // Example log messages
        Logger.LogInformation("Information log");
        Logger.LogWarning("Warning log");
        Logger.LogError("Error log");

        try
        {
            // Simulate an exception
            throw new Exception("Exception occurred");
        }
        catch (Exception ex)
        {
            // Log exception details
            Logger.LogError(ex, "Exception log");
        }

        Console.ReadKey(); // Wait for a key press before closing the application
    }
}

using Microsoft.Extensions.Logging;
using System;

class Program
{
    // Create a LoggerFactory instance
    private static readonly ILoggerFactory LoggerFactory = LoggerFactory.Create(builder =>
    {
        // Add console logger
        builder.AddConsole();
        // You can add other logging providers here (e.g., AddDebug, AddFile, etc.)
    });

    // Create a logger
    private static readonly ILogger Logger = LoggerFactory.CreateLogger<Program>();

    static void Main(string[] args)
    {
        // Example log messages
        Logger.LogInformation("Information log");
        Logger.LogWarning("Warning log");
        Logger.LogError("Error log");

        try
        {
            // Simulate an exception
            throw new Exception("Exception occurred");
        }
        catch (Exception ex)
        {
            // Log exception details
            Logger.LogError(ex, "Exception log");
        }

        Console.ReadKey(); // Wait for a key press before closing the application
    }
}

Imports Microsoft.Extensions.Logging
Imports System

Friend Class Program
	' Create a LoggerFactory instance
	Private Shared ReadOnly LoggerFactory As ILoggerFactory = LoggerFactory.Create(Sub(builder)
		' Add console logger
		builder.AddConsole()
		' You can add other logging providers here (e.g., AddDebug, AddFile, etc.)
	End Sub)

	' Create a logger
	Private Shared ReadOnly Logger As ILogger = LoggerFactory.CreateLogger(Of Program)()

	Shared Sub Main(ByVal args() As String)
		' Example log messages
		Logger.LogInformation("Information log")
		Logger.LogWarning("Warning log")
		Logger.LogError("Error log")

		Try
			' Simulate an exception
			Throw New Exception("Exception occurred")
		Catch ex As Exception
			' Log exception details
			Logger.LogError(ex, "Exception log")
		End Try

		Console.ReadKey() ' Wait for a key press before closing the application
	End Sub
End Class

Imports Microsoft.Extensions.Logging
Imports System

Friend Class Program
	' Create a LoggerFactory instance
	Private Shared ReadOnly LoggerFactory As ILoggerFactory = LoggerFactory.Create(Sub(builder)
		' Add console logger
		builder.AddConsole()
		' You can add other logging providers here (e.g., AddDebug, AddFile, etc.)
	End Sub)

	' Create a logger
	Private Shared ReadOnly Logger As ILogger = LoggerFactory.CreateLogger(Of Program)()

	Shared Sub Main(ByVal args() As String)
		' Example log messages
		Logger.LogInformation("Information log")
		Logger.LogWarning("Warning log")
		Logger.LogError("Error log")

		Try
			' Simulate an exception
			Throw New Exception("Exception occurred")
		Catch ex As Exception
			' Log exception details
			Logger.LogError(ex, "Exception log")
		End Try

		Console.ReadKey() ' Wait for a key press before closing the application
	End Sub
End Class

Dans cet exemple, un logger console est ajouté à la configuration de la journalisation, qui écrit des journaux sur la console. Cependant, Microsoft.Extensions.Logging propose divers fournisseurs de journalisation, y compris la journalisation vers des fichiers, des bases de données ou l'interconnexion avec d'autres frameworks de journalisation. Il est également possible de créer des fournisseurs de journalisation personnalisés qui peuvent formater les journaux selon des exigences spécifiques.

Inclure des fournisseurs supplémentaires pour la journalisation

Vous pouvez ajouter des sources de journalisation supplémentaires en chaînant les méthodes pertinentes au sein de la fonction Create(). Par exemple :

• Pour ajouter un fournisseur de journalisation de sortie de débogueur, utilisez builder.AddDebug().
• Pour ajouter un fournisseur de journalisation de fichier, utilisez builder.AddFile("log.txt").

MSLogging sur IronPDF

IronPDF excelle dans la conversion HTML vers PDF, garantissant une préservation précise des mises en page et styles originaux. Il est parfait pour créer des PDF à partir de contenus basés sur le Web tels que des rapports, des factures et de la documentation. Avec le support des fichiers HTML, des URLs et des chaînes HTML brutes, IronPDF produit facilement des documents PDF de haute qualité.

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

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

Pour activer la journalisation dans IronPDF, vous pouvez utiliser le framework Microsoft.Extensions.Logging ainsi que les capacités de journalisation intégrées d'IronPDF. Voici un exemple de comment configurer la journalisation dans IronPDF :

using Microsoft.Extensions.Logging;
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
        {
            builder
                .AddConsole()
                .AddDebug();
        });

        ILogger<Program> logger = loggerFactory.CreateLogger<Program>();

        // Enable logging in IronPDF
        Logger.Log = new LoggerImplementation(logger);

        // Use IronPDF and perform operations
        // ...

        // Example of logging an error in IronPDF
        Logger.Log.Error("An error occurred while processing the PDF");

        // Example of logging a warning in IronPDF
        Logger.Log.Warning("This is a warning message");

        // Example of logging an information message in IronPDF
        Logger.Log.Information("This is an information message");

        // ...

        // Close and dispose resources
        // ...

        // Flush the log messages
        loggerFactory.Dispose();
    }
}

using Microsoft.Extensions.Logging;
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
        {
            builder
                .AddConsole()
                .AddDebug();
        });

        ILogger<Program> logger = loggerFactory.CreateLogger<Program>();

        // Enable logging in IronPDF
        Logger.Log = new LoggerImplementation(logger);

        // Use IronPDF and perform operations
        // ...

        // Example of logging an error in IronPDF
        Logger.Log.Error("An error occurred while processing the PDF");

        // Example of logging a warning in IronPDF
        Logger.Log.Warning("This is a warning message");

        // Example of logging an information message in IronPDF
        Logger.Log.Information("This is an information message");

        // ...

        // Close and dispose resources
        // ...

        // Flush the log messages
        loggerFactory.Dispose();
    }
}

Imports Microsoft.Extensions.Logging
Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim loggerFactory As ILoggerFactory = LoggerFactory.Create(Sub(builder)
			builder.AddConsole().AddDebug()
		End Sub)

		Dim logger As ILogger(Of Program) = loggerFactory.CreateLogger(Of Program)()

		' Enable logging in IronPDF
		Logger.Log = New LoggerImplementation(logger)

		' Use IronPDF and perform operations
		' ...

		' Example of logging an error in IronPDF
		Logger.Log.Error("An error occurred while processing the PDF")

		' Example of logging a warning in IronPDF
		Logger.Log.Warning("This is a warning message")

		' Example of logging an information message in IronPDF
		Logger.Log.Information("This is an information message")

		' ...

		' Close and dispose resources
		' ...

		' Flush the log messages
		loggerFactory.Dispose()
	End Sub
End Class

Imports Microsoft.Extensions.Logging
Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim loggerFactory As ILoggerFactory = LoggerFactory.Create(Sub(builder)
			builder.AddConsole().AddDebug()
		End Sub)

		Dim logger As ILogger(Of Program) = loggerFactory.CreateLogger(Of Program)()

		' Enable logging in IronPDF
		Logger.Log = New LoggerImplementation(logger)

		' Use IronPDF and perform operations
		' ...

		' Example of logging an error in IronPDF
		Logger.Log.Error("An error occurred while processing the PDF")

		' Example of logging a warning in IronPDF
		Logger.Log.Warning("This is a warning message")

		' Example of logging an information message in IronPDF
		Logger.Log.Information("This is an information message")

		' ...

		' Close and dispose resources
		' ...

		' Flush the log messages
		loggerFactory.Dispose()
	End Sub
End Class

Dans cet exemple, nous créons une instance de LoggerFactory du framework Microsoft.Extensions.Logging. Nous créons ensuite un logger à partir de la factory pour la classe Program.

Pour activer la journalisation dans IronPDF, nous définissons la propriété statique Logger.Log sur une instance de LoggerImplementation qui prend le logger de loggerFactory. Avec cette configuration, vous pouvez utiliser les méthodes Logger.Log pour consigner les messages dans IronPDF.

Après avoir effectué les opérations nécessaires avec IronPDF, vous pouvez fermer et disposer des ressources, puis vider les messages de log en supprimant le loggerFactory.

Remarque : Assurez-vous d'avoir les dépendances et les packages nécessaires installés pour Microsoft.Extensions.Logging et IronPDF.

Installer IronPDF

Pour installer la bibliothèque IronPDF, suivez ces étapes :

1. Ouvrez la Console du gestionnaire de packages dans Visual Studio.
2. Entrez la commande suivante pour installer la bibliothèque IronPDF en utilisant NuGet :

Install-Package IronPdf

Alternativement, vous pouvez utiliser l'interface en ligne de commande .NET en exécutant la commande suivante dans le terminal :

Install-Package IronPdf

3. Appuyez sur Entrée pour exécuter la commande. Cela téléchargera et installera le package IronPDF dans votre projet.

Il est également possible d'installer la bibliothèque IronPDF en utilisant l'interface graphique du gestionnaire de packages NuGet. Il suffit de rechercher le package "IronPDF" dans l'onglet Parcourir, de sélectionner le package souhaité dans la liste, et d'installer la dernière version d'IronPDF.

Une fois l'installation terminée, vous pouvez commencer à utiliser la bibliothèque IronPDF dans votre projet.

MS Logging avec IronPDF

En janvier 2022, IronPDF n'interagit pas directement avec Microsoft.Extensions.Logging et n'est pas pris en charge nativement. IronPDF est principalement utilisé comme un outil pour créer et modifier des PDF dans les programmes C#.

Cependant, vous pouvez toujours intégrer la journalisation en utilisant Microsoft.Extensions. En intégrant la journalisation dans votre programme C# en parallèle avec IronPDF, vous pouvez gérer et journaliser les événements liés à la production de PDF, au flux de travail de l'application, ou aux problèmes qui surviennent lors de l'utilisation d'IronPDF.

Voici un exemple de comment utiliser Microsoft.Extensions pour intégrer la journalisation avec IronPDF :

using Microsoft.Extensions.Logging;
using IronPdf;
using System;

class Program
{
    private static readonly ILoggerFactory LoggerFactory = LoggerFactory.Create(builder =>
    {
        builder.AddConsole(); // Add other logging providers as needed
    });

    private static readonly ILogger Logger = LoggerFactory.CreateLogger<Program>();

    static void Main(string[] args)
    {
        try
        {
            // Your IronPDF code for PDF generation or manipulation
            var Renderer = new IronPdf.HtmlToPdf();
            var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello World!</h1>");
            PDF.SaveAs("Output.pdf");
            Logger.LogInformation("PDF created successfully.");
        }
        catch (Exception ex)
        {
            Logger.LogError(ex, "An error occurred while generating the PDF.");
        }

        Console.ReadKey(); // Wait for a key press before closing the application
    }
}

using Microsoft.Extensions.Logging;
using IronPdf;
using System;

class Program
{
    private static readonly ILoggerFactory LoggerFactory = LoggerFactory.Create(builder =>
    {
        builder.AddConsole(); // Add other logging providers as needed
    });

    private static readonly ILogger Logger = LoggerFactory.CreateLogger<Program>();

    static void Main(string[] args)
    {
        try
        {
            // Your IronPDF code for PDF generation or manipulation
            var Renderer = new IronPdf.HtmlToPdf();
            var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello World!</h1>");
            PDF.SaveAs("Output.pdf");
            Logger.LogInformation("PDF created successfully.");
        }
        catch (Exception ex)
        {
            Logger.LogError(ex, "An error occurred while generating the PDF.");
        }

        Console.ReadKey(); // Wait for a key press before closing the application
    }
}

Imports Microsoft.Extensions.Logging
Imports IronPdf
Imports System

Friend Class Program
	Private Shared ReadOnly LoggerFactory As ILoggerFactory = LoggerFactory.Create(Sub(builder)
		builder.AddConsole() ' Add other logging providers as needed
	End Sub)

	Private Shared ReadOnly Logger As ILogger = LoggerFactory.CreateLogger(Of Program)()

	Shared Sub Main(ByVal args() As String)
		Try
			' Your IronPDF code for PDF generation or manipulation
			Dim Renderer = New IronPdf.HtmlToPdf()
			Dim PDF = Renderer.RenderHtmlAsPdf("<h1>Hello World!</h1>")
			PDF.SaveAs("Output.pdf")
			Logger.LogInformation("PDF created successfully.")
		Catch ex As Exception
			Logger.LogError(ex, "An error occurred while generating the PDF.")
		End Try

		Console.ReadKey() ' Wait for a key press before closing the application
	End Sub
End Class

Imports Microsoft.Extensions.Logging
Imports IronPdf
Imports System

Friend Class Program
	Private Shared ReadOnly LoggerFactory As ILoggerFactory = LoggerFactory.Create(Sub(builder)
		builder.AddConsole() ' Add other logging providers as needed
	End Sub)

	Private Shared ReadOnly Logger As ILogger = LoggerFactory.CreateLogger(Of Program)()

	Shared Sub Main(ByVal args() As String)
		Try
			' Your IronPDF code for PDF generation or manipulation
			Dim Renderer = New IronPdf.HtmlToPdf()
			Dim PDF = Renderer.RenderHtmlAsPdf("<h1>Hello World!</h1>")
			PDF.SaveAs("Output.pdf")
			Logger.LogInformation("PDF created successfully.")
		Catch ex As Exception
			Logger.LogError(ex, "An error occurred while generating the PDF.")
		End Try

		Console.ReadKey() ' Wait for a key press before closing the application
	End Sub
End Class

Cet exemple montre une manière simple de configurer Microsoft.Extensions.Logging au sein d'une application C# avec IronPDF. Les messages de journal sont générés pour documenter la création réussie de PDF et pour enregistrer les exceptions pouvant survenir.

Assurez-vous de personnaliser les niveaux de journalisation, la gestion des erreurs et les messages selon les besoins spécifiques de votre application et les scénarios dans lesquels IronPDF est utilisé pour la création ou la modification de PDF. Différencier correctement entre les différents types de messages de journal à l'aide des niveaux de journalisation peut être utile pour un débogage efficace et une surveillance.

Pour en savoir plus sur IronPDF, veuillez visiter la page d'accueil d'IronPDF,.

Conclusion

En conclusion, l'intégration de Microsoft.Extensions.Logging permet aux développeurs C# de gérer efficacement les tâches de journalisation. IronPDF fournit des capacités de journalisation complètes, permettant un enregistrement, une analyse et une création de rapports approfondis des événements de l'application, des échecs et des données vitales. Cela améliore la fiabilité, la maintenance et le débogage de l'application.

IronPDF propose différents produits logiciels, y compris un ensemble Lite au prix de $999. Cet ensemble inclut une licence permanente, des options de mise à jour, un an de maintenance logicielle, et une garantie de remboursement de trente jours. Pendant la période d'essai avec filigrane, vous pouvez explorer les fonctionnalités d'IronPDF. Pour en savoir plus sur les produits logiciels offerts par Iron Software, veuillez visiter le site officiel d'Iron Software.