Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. NLog C#
.NET AIDE

NLog C# (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

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".

    Nlog Csharp Guide 1 related to Créer un fichier de configuration NLog

  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>
XML

Dans votre code C#, assurez-vous de charger la configuration NLog à partir du fichier nlog.config. Vous faites cela généralement dans le code de démarrage de l'application, comme dans le Startup.cs d'ASP.NET Core (pour la Version .NET égale ou inférieure à .NET 5), le fichier program.cs (pour .NET 6 ou version ultérieure) ou 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(ByVal 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
$vbLabelText   $csharpLabel

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

Nlog Csharp Guide 2 related to Fichier de config

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 l'opération 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éfinissez minlevel="Trace" dans le tag des règles dans 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>
XML

Écrivons du code pour journaliser 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
$vbLabelText   $csharpLabel

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

messages du journal nlog

Maintenant, nous avons démontré l'exemple de journalisation de messages dans la Console. Nous allons maintenant configurer une cible NLog pour journaliser 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>
XML

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

Nlog Csharp Guide 4 related to Enregistrer un message 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 journal par emails.
  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
$vbLabelText   $csharpLabel

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 gestionnaire de paquets NuGet dans Visual Studio ou via l'interface 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.

É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
$vbLabelText   $csharpLabel

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

Nlog Csharp Guide 5 related to 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.

Questions Fréquemment Posées

Comment NLog améliore-t-il la journalisation dans les applications C#?

NLog fournit un framework de journalisation robuste et flexible pour les applications C#. Il permet aux développeurs d’implémenter facilement la journalisation en définissant les cibles et les règles de journal dans un fichier de configuration, prenant en charge divers niveaux de journalisation tels que Trace, Debug, Info, Warn, Error et Fatal.

Quel est le processus pour configurer NLog dans une application .NET?

Pour configurer NLog dans une application .NET, vous devez installer le package NuGet NLog et configurer les cibles et règles de journalisation dans le fichier nlog.config. Cette configuration vous permet de spécifier où les journaux doivent être dirigés, tels que des fichiers, des consoles, des bases de données ou des e-mails.

Comment puis-je enregistrer des messages dans une base de données en utilisant NLog?

Pour enregistrer des messages dans une base de données en utilisant NLog, vous devez configurer une cible de base de données dans le fichier nlog.config. Vous devez spécifier la chaîne de connexion et les détails nécessaires de la table ou de la procédure stockée pour les entrées de journal.

NLog peut-il être utilisé pour envoyer des messages de journal par e-mail?

Oui, NLog peut envoyer des messages de journal par e-mail en configurant une cible d'e-mail dans le fichier nlog.config. Vous devrez fournir les détails du serveur SMTP, les adresses e-mail des destinataires et d'autres paramètres de messagerie.

Quels sont les avantages d'utiliser IronPDF pour la génération de PDF dans .NET ?

IronPDF est une puissante bibliothèque .NET qui simplifie la génération, l'édition et la conversion de PDF. Elle prend en charge la conversion HTML en PDF, permettant aux développeurs de générer des PDF à partir de chaînes HTML, de fichiers ou d'URL, améliorant ainsi les processus de reporting et de gestion de documents.

Comment puis-je intégrer la journalisation avec la génération de PDF dans une application C#?

Vous pouvez intégrer NLog avec IronPDF dans une application C# en utilisant NLog pour enregistrer les événements de l'application et IronPDF pour générer des PDF. Cette combinaison vous permet de créer des rapports PDF détaillés qui incluent des informations de journal.

Quelles sont quelques étapes courantes de dépannage pour les problèmes de configuration de NLog?

Les étapes courantes de dépannage pour les problèmes de configuration de NLog incluent la vérification du fichier nlog.config pour les erreurs de syntaxe, l'assurance des chemins de fichiers corrects et les permissions pour les cibles de journal, et la vérification des exceptions dans l'application pouvant affecter la journalisation.

Comment puis-je tester les capacités d'IronPDF avant l'achat?

IronPDF offre un essai gratuit qui permet aux développeurs de tester ses fonctionnalités. Cette période d'essai offre l'opportunité d'évaluer les capacités d'IronPDF pour la génération, l'édition et la conversion de PDF avant d'opter pour une licence commerciale.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit