La journalisation est un aspect essentiel du développement de logiciels. Il aide les développeurs à suivre le comportement de leurs applications, à résoudre les problèmes et à comprendre comment leur code fonctionne dans différents environnements. NLog est un cadre de journalisation populaire pour C# qui facilite la mise en œuvre d'une journalisation robuste et flexible dans vos applications. Dans ce guide et tutoriel complet, nous allons explorer le monde de NLog en C#.

Qu'est-ce que NLog ?

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

Démarrer avec NLog

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

Installer le paquetage Nuget nLog

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

1. Dans le menu "Outils", sélectionnez "NuGet Package Manager", puis "Gérer les paquets NuGet pour la solution"

2. Vous pouvez également cliquer avec le bouton droit de la souris sur votre projet dans l'explorateur de solutions, sélectionner "Manage NuGet Packages" et choisir "Browse"

3. Dans la fenêtre NuGet Package Manager, cliquez sur l'onglet "Browse", et dans la boîte de recherche, tapez "NLog"

4. Vous devriez voir le paquet NLog dans les résultats de la recherche. Cliquez dessus pour le sélectionner.

5. La partie droite de la fenêtre du gestionnaire de paquets NuGet contient une liste des projets de votre solution. Sélectionner le projet(s) où vous souhaitez installer NLog.

6. Choisissez la version souhaitée du paquet NLog dans le menu déroulant de la version. Vous pouvez sélectionner la dernière version stable ou une version spécifique si nécessaire.

7. Après avoir sélectionné le projet(s) et la version, cliquez sur le bouton "Installer" pour lancer le processus d'installation.

   Le gestionnaire de paquets NuGet téléchargera et installera NLog et toutes les 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(typiquement nommé nlog.config)vous pouvez suivre les étapes suivantes. Ce fichier de configuration spécifie comment NLog doit se comporter dans votre application, notamment en ce qui concerne les cibles des journaux, les rendus de présentation et les règles.

Dans votre projet, cliquez avec le bouton droit de la souris sur le projet ou le dossier souhaité dans lequel vous souhaitez 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 enregistre les messages vers une cible Console. Vous pouvez personnaliser ce fichier de configuration en fonction de vos besoins :

Fichier de configuration

<?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 file -->
    <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 file -->
    <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, par exemple dans un fichier ASP.NET Core Startup.cs(pour la version .NET identique ou antérieure à .NET 5)fichier program.cs(pour .NET 6 ou une version ultérieure) ou la méthode Main d'une application console :

internal class Program
{
    private static Logger logger = LogManager.GetCurrentClassLogger();
    static void Main(string [] args)
    {
        logger.Debug("This is Debug Message");
        Console.Read();
    }
}

internal class Program
{
    private static Logger logger = LogManager.GetCurrentClassLogger();
    static void Main(string [] args)
    {
        logger.Debug("This is Debug Message");
        Console.Read();
    }
}

Friend Class Program
	Private Shared logger As Logger = LogManager.GetCurrentClassLogger()
	Shared Sub Main(ByVal args() As String)
		logger.Debug("This is Debug Message")
		Console.Read()
	End Sub
End Class

La sortie du programme ci-dessus est la suivante :

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

Niveaux de journalisation

NLog prend en charge plusieurs niveaux de journalisation, chacun ayant sa propre signification :

1. Trace : Le niveau le plus détaillé, généralement utilisé à des fins de diagnostic.

2. Debug (débogage) : Utilisé pour les informations de débogage qui peuvent être utiles pendant le développement.

3. Info : Informations générales sur le fonctionnement de l'application.

4. Avertir : Indique un problème potentiel qui ne perturbe pas l'application.

5. Erreur : Indique une défaillance qui doit être examinée, mais qui n'entraîne pas nécessairement le blocage de l'application.

6. Fatal : indique une défaillance critique qui doit être traitée immédiatement.

   En classant les messages du journal selon ces niveaux, vous pouvez facilement les filtrer et les classer par ordre de priorité en fonction de leur gravité.

   Définissez minlevel="Trace" dans la balise rules 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 un code pour enregistrer les messages de tous les niveaux de traçage.

internal class Program
{
    private static Logger logger = LogManager.GetCurrentClassLogger();
    static void Main(string [] args)
    {
        logger.Trace("This is Trace Message");
        logger.Debug("This is Debug Message");
        logger.Info("This is Info Message");
        logger.Warn("This is Warning Message");
        logger.Error("This is Error Message");
        logger.Fatal("This is Fatal Message");
        Console.Read();
    }
}

internal class Program
{
    private static Logger logger = LogManager.GetCurrentClassLogger();
    static void Main(string [] args)
    {
        logger.Trace("This is Trace Message");
        logger.Debug("This is Debug Message");
        logger.Info("This is Info Message");
        logger.Warn("This is Warning Message");
        logger.Error("This is Error Message");
        logger.Fatal("This is Fatal Message");
        Console.Read();
    }
}

Friend Class Program
	Private Shared logger As Logger = LogManager.GetCurrentClassLogger()
	Shared Sub Main(ByVal args() As String)
		logger.Trace("This is Trace Message")
		logger.Debug("This is Debug Message")
		logger.Info("This is Info Message")
		logger.Warn("This is Warning Message")
		logger.Error("This is Error Message")
		logger.Fatal("This is Fatal Message")
		Console.Read()
	End Sub
End Class

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

Nous avons montré l'exemple de l'enregistrement des messages dans la console. Nous allons maintenant configurer la cible NLog pour enregistrer les messages dans le fichier.

Message du journal dans le fichier

Nous devons définir une cible de fichier au lieu d'une cible de console dans notre fichier de configuration pour l'enregistrement des fichiers.

  <targets>
  <target xsi:type="File" name="fileTarget" fileName="D:\Logs\mylog.txt" layout="${longdate} ${level:uppercase=true} ${message}" />
</targets>

<rules>
  <logger name="*" minlevel="Trace" writeTo="fileTarget" />
</rules>

  <targets>
  <target xsi:type="File" name="fileTarget" fileName="D:\Logs\mylog.txt" layout="${longdate} ${level:uppercase=true} ${message}" />
</targets>

<rules>
  <logger name="*" minlevel="Trace" writeTo="fileTarget" />
</rules>

Exécutez maintenant le programme pour enregistrer les messages dans un fichier.

Cibles d'enregistrement

NLog prend en charge différentes cibles de sortie des journaux, ce qui vous permet de choisir l'endroit où vos messages doivent être stockés. Parmi les cibles les plus courantes, on peut citer

1. Fichier : enregistre les messages dans un ou plusieurs fichiers.

2. Console : Enregistre les messages dans la console.

3. Base de données : Enregistre les messages dans une base de données(SQL Server, MySQL, Oracle, PostgreSQL, etc.) table.

4. Email : Envoie les messages du journal sous forme de courrier électronique.

5. Journal des événements : Enregistre les messages dans le journal des événements de Windows.

6. Cibles personnalisées : Vous pouvez créer des objectifs d'enregistrement personnalisés pour répondre à vos besoins spécifiques.

   Vous pouvez configurer NLog pour qu'il utilise une ou plusieurs cibles simultanément.

Présentation d'IronPDF

En savoir plus sur IronPDF est une puissante bibliothèque .NET qui simplifie la gestion des PDF dans les applications C# et VB.NET. Il offre de solides capacités de création, d'édition et de manipulation de documents PDF, ainsi que de conversion de contenu HTML au format PDF, ce qui en fait un outil essentiel pour les développeurs dans un large éventail de secteurs, notamment le développement web, la création de rapports et la gestion de documents.

La caractéristique la plus remarquable d'IronPDF est sonConversion de HTML en PDF qui permet de préserver les mises en page et les styles. Il génère des PDF à partir de contenus web, ce qui en fait un outil idéal pour les rapports, les factures et la documentation. Les fichiers HTML, les URL et les chaînes HTML peuvent être facilement convertis en 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");
    }
}

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

Générons un PDF avec enregistrement.

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 gestionnaire de paquets NuGet dans Visual Studio ou via le CLI NuGet. Ouvrez votre projet et écrivez la commande suivante dans la console du gestionnaire de paquets.

Install-Package IronPdf

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

Ecrivez le code suivant pour générer un fichier PDF à partir d'un fichier HTML avec journalisation.

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

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

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

L'extrait de code ci-dessus créera un fichier PDF avec un message enregistré dans le fichier, comme indiqué ci-dessous.

Journal et fichier 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 journalisation. Sa flexibilité et sa facilité d'utilisation en font un choix de premier ordre pour répondre aux besoins de journalisation dans différents domaines. En outre, lorsqu'ils sont associés à des bibliothèques complémentaires comme IronPDF, qui simplifie la génération et la manipulation de fichiers PDF dans les applications .NET, les développeurs peuvent étendre leurs capacités de gestion à la création de journaux et de rapports au format PDF. Il convient de mentionner qu'IronPDF offreun essai gratuit d'IronPDF pour tester ses fonctionnalités. S'il répond à vos besoins, vous pouvez opter pour unlicence commerciale pour IronPDFla nouvelle version du logiciel IronPDF offre un accès continu aux capacités d'IronPDF avec des avantages supplémentaires et un soutien pour une intégration transparente dans vos projets, en particulier pour les fonctionnalités liées au format PDF.

En utilisant conjointement la puissance de NLog et d'IronPDF, les développeurs peuvent non seulement obtenir des informations sur le comportement de leur application, mais aussi améliorer leurs processus de création de rapports et de gestion de documents, en veillant à ce que leur logiciel reste efficace, maintenable et bien documenté en matière de journalisation structurée.