La journalisation est un aspect essentiel du développement de logiciels. Elle aide les développeurs à suivre le comportement de leurs applications, à résoudre les problèmes et à obtenir des informations sur les performances de leur code dans divers environnements. NLog est un framework de journalisation populaire pour C# qui facilite l'implémentation d'une journalisation robuste et flexible dans vos applications. Dans ce guide complet et tutoriel, nous explorerons le monde de NLog en C#.

Qu'est-ce que NLog ?

NLog est une bibliothèque de journalisation gratuite et open-source pour les applications .NET et .NET Core. Elle offre un moyen flexible et hautement configurable de journaliser les messages dans votre application. NLog est une plateforme de journalisation gratuite largement utilisée dans l'écosystème .NET en raison de ses performances, de son extensibilité et de sa facilité d'utilisation.

Commencer avec NLog

Nous pouvons utiliser NLog dans les applications Web ASP.NET, les APIs WEB ASP.NET, les applications de formulaire Windows, les applications ASP.NET MVC, ou tout autre type selon nos besoins. Nous utiliserons l'application Console pour démontrer tous les cas d'utilisation.

Installer le package NuGet NLog

Pour commencer avec NLog, vous devez installer le package NuGet NLog dans votre projet. Vous pouvez le faire via le gestionnaire de packages NuGet dans Visual Studio en suivant les étapes suivantes :

1. Dans le menu "Outils", sélectionnez "Gestionnaire de packages NuGet", puis choisissez "Gérer les packages NuGet pour la solution".
2. Ou, cliquez avec le bouton droit sur votre projet dans l'Explorateur de solutions, sélectionnez "Gérer les packages NuGet", puis choisissez "Parcourir".
3. Dans la fenêtre du gestionnaire de packages NuGet, cliquez sur l'onglet "Parcourir", et dans la boîte de recherche, tapez "NLog".
4. Vous devriez voir le package NLog dans les résultats de recherche. Cliquez dessus pour le sélectionner.
5. Sur le côté droit de la fenêtre du gestionnaire de packages NuGet, il y a une liste de projets dans votre solution. Sélectionnez le ou les projets dans lesquels vous souhaitez installer NLog.
6. Choisissez la version souhaitée du package NLog dans le menu déroulant des versions. Vous pouvez choisir la dernière version stable ou une version spécifique si nécessaire.
7. Après avoir sélectionné le(s) projet(s) et la version, cliquez sur le bouton "Installer" pour lancer le processus d'installation.

Le gestionnaire de packages NuGet téléchargera et installera NLog et toutes ses dépendances. Vous verrez la progression dans la fenêtre de sortie.

NLog est maintenant installé avec succès dans votre projet, et vous pouvez commencer à l'utiliser pour la journalisation dans votre code C#.

Créer un fichier de configuration NLog

Pour créer un fichier de configuration NLog (généralement nommé nlog.config), vous pouvez suivre ces étapes. Ce fichier de configuration spécifiera comment NLog doit se comporter dans votre application, y compris les cibles de journalisation, les rendus de mise en page et les règles.

Dans votre projet, cliquez avec le bouton droit sur le projet ou le dossier désiré où vous voulez créer le fichier de configuration.

1. Choisissez "Ajouter" > "Nouvel élément..."
2. Dans la boîte de dialogue "Ajouter un nouvel élément", recherchez "Fichier XML" ou "XML" et sélectionnez-le.
3. Nommez le fichier nlog.config et cliquez sur le bouton "Ajouter".

4. Ouvrez le fichier nlog.config nouvellement créé dans un éditeur de texte ou un éditeur XML.
5. Ajoutez la configuration suivante dans le fichier NLog.XML. Voici un exemple de base d'une configuration NLog qui journalise les messages vers une cible Console. Vous pouvez personnaliser ce fichier de configuration pour répondre à vos besoins :

Fichier de config

<?xml version="1.0" encoding="utf-8" ?>
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

  <!-- Define targets -->
  <targets>
    <!-- Log to a console -->
    <target name="console" xsi:type="Console" layout="${longdate}|${message}"/>
  </targets>

  <!-- Define rules -->
  <rules>
    <!-- All messages with a minimum log level of Debug or higher are written to the Console -->
    <logger name="*" minlevel="Debug" writeTo="console" />
  </rules>

</nlog>

<?xml version="1.0" encoding="utf-8" ?>
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

  <!-- Define targets -->
  <targets>
    <!-- Log to a console -->
    <target name="console" xsi:type="Console" layout="${longdate}|${message}"/>
  </targets>

  <!-- Define rules -->
  <rules>
    <!-- All messages with a minimum log level of Debug or higher are written to the Console -->
    <logger name="*" minlevel="Debug" writeTo="console" />
  </rules>

</nlog>

Dans votre code C#, assurez-vous de charger la configuration NLog à partir du fichier nlog.config. Vous le faites généralement dans le code de démarrage de l'application, comme dans un fichier Startup.cs d'ASP.NET Core (pour une Version .NET égale ou antérieure à .NET 5), dans un fichier program.cs (for .NET 6 ou une version ultérieure), ou dans la méthode Main d'une application console :

using NLog;

internal class Program
{
    // Create an instance of the Logger
    private static Logger logger = LogManager.GetCurrentClassLogger();

    static void Main(string[] args)
    {
        // Log a debug message
        logger.Debug("This is a Debug Message");
        
        // Pause the console for viewing output
        Console.Read();
    }
}

using NLog;

internal class Program
{
    // Create an instance of the Logger
    private static Logger logger = LogManager.GetCurrentClassLogger();

    static void Main(string[] args)
    {
        // Log a debug message
        logger.Debug("This is a Debug Message");
        
        // Pause the console for viewing output
        Console.Read();
    }
}

Imports NLog

Friend Class Program
    ' Create an instance of the Logger
    Private Shared logger As Logger = LogManager.GetCurrentClassLogger()

    Shared Sub Main(args As String())
        ' Log a debug message
        logger.Debug("This is a Debug Message")

        ' Pause the console for viewing output
        Console.Read()
    End Sub
End Class

Imports NLog

Friend Class Program
    ' Create an instance of the Logger
    Private Shared logger As Logger = LogManager.GetCurrentClassLogger()

    Shared Sub Main(args As String())
        ' Log a debug message
        logger.Debug("This is a Debug Message")

        ' Pause the console for viewing output
        Console.Read()
    End Sub
End Class

La sortie du programme ci-dessus est montrée :

Dans cet exemple, nous créons une instance de la classe Logger et l'utilisons pour journaliser des messages au niveau Debug. Explorons le niveau de traçage supporté par NLog.

Niveaux de journalisation

NLog supporte plusieurs niveaux de journalisation, chacun avec sa propre signification :

1. Trace : Le niveau le plus détaillé, généralement utilisé à des fins de diagnostic.
2. Débogage : Utilisé pour des informations de débogage qui peuvent être utiles lors du développement.
3. Info : Informations générales sur le fonctionnement de l'application.
4. Avertissement : Indique un problème potentiel qui ne perturbe pas l'application.
5. Erreur : Indique une défaillance qui doit être investiguée mais qui ne fait pas nécessairement planter l'application.
6. Fatal : Indique une défaillance critique qui doit être traitée immédiatement.

En catégorisant les messages de journal par ces niveaux, vous pouvez facilement les filtrer et les prioriser en fonction de leur gravité.

Définir minlevel="Trace" dans la balise des règles de votre fichier nLog.Config comme indiqué ci-dessous.

<rules>
  <!-- All messages with a minimum log level of Trace or higher are written to the Console -->
  <logger name="*" minlevel="Trace" writeTo="console" />
</rules>

<rules>
  <!-- All messages with a minimum log level of Trace or higher are written to the Console -->
  <logger name="*" minlevel="Trace" writeTo="console" />
</rules>

Écrivons du code pour enregistrer les messages de tous les niveaux de traçage.

using NLog;

internal class Program
{
    // Create an instance of the Logger
    private static Logger logger = LogManager.GetCurrentClassLogger();

    static void Main(string[] args)
    {
        // Log messages of different tracking levels
        logger.Trace("This is a Trace Message");
        logger.Debug("This is a Debug Message");
        logger.Info("This is an Info Message");
        logger.Warn("This is a Warning Message");
        logger.Error("This is an Error Message");
        logger.Fatal("This is a Fatal Message");

        // Pause the console for viewing output
        Console.Read();
    }
}

using NLog;

internal class Program
{
    // Create an instance of the Logger
    private static Logger logger = LogManager.GetCurrentClassLogger();

    static void Main(string[] args)
    {
        // Log messages of different tracking levels
        logger.Trace("This is a Trace Message");
        logger.Debug("This is a Debug Message");
        logger.Info("This is an Info Message");
        logger.Warn("This is a Warning Message");
        logger.Error("This is an Error Message");
        logger.Fatal("This is a Fatal Message");

        // Pause the console for viewing output
        Console.Read();
    }
}

Imports NLog

Friend Class Program
	' Create an instance of the Logger
	Private Shared logger As Logger = LogManager.GetCurrentClassLogger()

	Shared Sub Main(ByVal args() As String)
		' Log messages of different tracking levels
		logger.Trace("This is a Trace Message")
		logger.Debug("This is a Debug Message")
		logger.Info("This is an Info Message")
		logger.Warn("This is a Warning Message")
		logger.Error("This is an Error Message")
		logger.Fatal("This is a Fatal Message")

		' Pause the console for viewing output
		Console.Read()
	End Sub
End Class

Imports NLog

Friend Class Program
	' Create an instance of the Logger
	Private Shared logger As Logger = LogManager.GetCurrentClassLogger()

	Shared Sub Main(ByVal args() As String)
		' Log messages of different tracking levels
		logger.Trace("This is a Trace Message")
		logger.Debug("This is a Debug Message")
		logger.Info("This is an Info Message")
		logger.Warn("This is a Warning Message")
		logger.Error("This is an Error Message")
		logger.Fatal("This is a Fatal Message")

		' Pause the console for viewing output
		Console.Read()
	End Sub
End Class

Notre programme a enregistré des messages dans la Console comme indiqué ci-dessous.

Maintenant, nous avons démontré l'exemple de journalisation de messages dans la Console. Nous allons maintenant configurer une cible NLog pour enregistrer les messages dans le fichier.

Enregistrer un message dans un fichier

Nous devons définir une cible de fichier au lieu d'une cible Console dans notre fichier de configuration pour la journalisation dans le fichier.

<targets>
  <!-- Log to a file at specified location -->
  <target xsi:type="File" name="fileTarget" fileName="D:\Logs\mylog.txt" layout="${longdate} ${level:uppercase=true} ${message}" />
</targets>

<rules>
  <!-- All messages with a minimum log level of Trace or higher are written to the file -->
  <logger name="*" minlevel="Trace" writeTo="fileTarget" />
</rules>

<targets>
  <!-- Log to a file at specified location -->
  <target xsi:type="File" name="fileTarget" fileName="D:\Logs\mylog.txt" layout="${longdate} ${level:uppercase=true} ${message}" />
</targets>

<rules>
  <!-- All messages with a minimum log level of Trace or higher are written to the file -->
  <logger name="*" minlevel="Trace" writeTo="fileTarget" />
</rules>

Lancez maintenant le programme pour journaliser les messages dans un fichier.

Cibles de journalisation

NLog supporte divers cibles de sortie de journal, vous permettant de choisir où vos messages de journal doivent être stockés. Certaines cibles communes incluent :

1. Fichier : Enregistre les messages dans un ou plusieurs fichiers.
2. Console : Enregistre les messages sur la console.
3. Base de données : Enregistre les messages dans une table de base de données (SQL Server, MySQL, Oracle, PostgreSQL, etc.).
4. Email : Envoie les messages de journalisation par email.
5. Journal des événements : Enregistre les messages dans le Journal des événements Windows.
6. Cibles personnalisées : Vous pouvez créer des cibles de journal personnalisées pour répondre à vos besoins spécifiques.

Vous pouvez configurer NLog pour utiliser une ou plusieurs cibles simultanément.

Présentation d'IronPDF

Explorer davantage IronPDF est une bibliothèque .NET puissante qui simplifie la gestion des PDF dans les applications C# et VB.NET. Elle offre des capacités robustes pour créer, éditer et manipuler des documents PDF, ainsi que pour convertir du contenu HTML en format PDF, en faisant un outil essentiel pour les développeurs dans un large éventail d'industries, y compris le développement web, le reporting et la gestion de documents.

La fonctionnalité phare d'IronPDF est sa fonction de Conversion HTML en PDF, qui conserve vos mises en page et styles. Elle génère des PDF à partir de contenu web, ce qui la rend idéale pour les rapports, les factures et la documentation. Les fichiers HTML, les URLs et les chaînes HTML peuvent être facilement convertis en PDFs.

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

Générons un PDF avec journalisation.

Génération de PDF avec journalisation

La première étape consiste à installer la bibliothèque IronPDF dans notre projet. Nous pouvons le faire en utilisant le Package Manager NuGet dans Visual Studio ou via l'interface CLI NuGet. Ouvrez votre projet et écrivez la commande suivante dans la console du Package Manager.

Install-Package IronPdf

Cette commande installera IronPDF avec toutes les dépendances requises dans notre projet.

Écrivez le code suivant pour générer un fichier PDF à partir de HTML avec journalisation.

using NLog;
using IronPdf;

internal class Program
{
    // Create an instance of the Logger
    private static Logger logger = LogManager.GetCurrentClassLogger();

    static void Main(string[] args)
    {
        logger.Info("Initializing Chrome PDF Renderer");
        ChromePdfRenderer renderer = new ChromePdfRenderer();

        logger.Info("Creating PDF From HTML String");
        var pdf = renderer.RenderHtmlAsPdf("<h1>This is my Sample PDF<h1>");

        logger.Info("Saving PDF File");
        pdf.SaveAs(@"D:\myPDF.pdf");
    }
}

using NLog;
using IronPdf;

internal class Program
{
    // Create an instance of the Logger
    private static Logger logger = LogManager.GetCurrentClassLogger();

    static void Main(string[] args)
    {
        logger.Info("Initializing Chrome PDF Renderer");
        ChromePdfRenderer renderer = new ChromePdfRenderer();

        logger.Info("Creating PDF From HTML String");
        var pdf = renderer.RenderHtmlAsPdf("<h1>This is my Sample PDF<h1>");

        logger.Info("Saving PDF File");
        pdf.SaveAs(@"D:\myPDF.pdf");
    }
}

Imports NLog
Imports IronPdf

Friend Class Program
	' Create an instance of the Logger
	Private Shared logger As Logger = LogManager.GetCurrentClassLogger()

	Shared Sub Main(ByVal args() As String)
		logger.Info("Initializing Chrome PDF Renderer")
		Dim renderer As New ChromePdfRenderer()

		logger.Info("Creating PDF From HTML String")
		Dim pdf = renderer.RenderHtmlAsPdf("<h1>This is my Sample PDF<h1>")

		logger.Info("Saving PDF File")
		pdf.SaveAs("D:\myPDF.pdf")
	End Sub
End Class

Imports NLog
Imports IronPdf

Friend Class Program
	' Create an instance of the Logger
	Private Shared logger As Logger = LogManager.GetCurrentClassLogger()

	Shared Sub Main(ByVal args() As String)
		logger.Info("Initializing Chrome PDF Renderer")
		Dim renderer As New ChromePdfRenderer()

		logger.Info("Creating PDF From HTML String")
		Dim pdf = renderer.RenderHtmlAsPdf("<h1>This is my Sample PDF<h1>")

		logger.Info("Saving PDF File")
		pdf.SaveAs("D:\myPDF.pdf")
	End Sub
End Class

Le fragment de code ci-dessus créera un fichier PDF avec un message journalisé dans le fichier comme indiqué ci-dessous.

Fichier de journal et PDF

Conclusion

En conclusion, NLog s'est imposé comme un outil essentiel pour une journalisation efficace dans les applications C#, offrant aux développeurs un cadre robuste pour capturer, catégoriser et gérer les données de journal. Sa flexibilité et sa facilité d'utilisation en font un choix incontournable pour les besoins de journalisation dans divers domaines. De plus, lorsqu'il est combiné avec des bibliothèques complémentaires comme IronPDF, qui simplifie la génération et la manipulation de PDF dans les applications .NET, les développeurs peuvent étendre leurs capacités de gestion pour inclure la création de journaux et rapports basés sur les PDF. Il convient de mentionner qu'IronPDF offre un essai gratuit d'IronPDF pour tester ses fonctionnalités. Si cela répond à vos besoins, vous pouvez opter pour une licence commerciale pour IronPDF, offrant un accès continu aux capacités d'IronPDF avec des avantages supplémentaires et un support pour une intégration transparente dans vos projets, notamment pour les fonctionnalités liées aux PDF.

En utilisant la puissance de NLog et IronPDF ensemble, les développeurs peuvent non seulement obtenir des informations sur le comportement de leur application mais aussi améliorer leurs processus de reporting et de gestion de documents, garantissant que leur logiciel reste efficace, maintenable et bien documenté avec une journalisation structurée.