Die Protokollierung ist ein wesentlicher Aspekt der Softwareentwicklung. Es hilft Entwicklern, das Verhalten ihrer Anwendungen zu verfolgen, Probleme zu beheben und Einblicke in die Leistung ihres Codes in verschiedenen Umgebungen zu gewinnen. NLog ist ein beliebtes Logging-Framework für C#, mit dem Sie auf einfache Weise robuste und flexible Protokollierung in Ihren Anwendungen implementieren können. In diesem umfassenden Leitfaden und Tutorial werden wir die Welt von NLog in C# erkunden.

Was ist NLog?

NLog ist eine freie, quelloffene Protokollierungsbibliothek für .NET- und .NET Core-Anwendungen. Es bietet eine flexible und hochgradig konfigurierbare Möglichkeit zur Protokollierung von Meldungen in Ihrer Anwendung. NLog ist aufgrund seiner Leistung, Erweiterbarkeit und Benutzerfreundlichkeit eine weit verbreitete freie Protokollierungsplattform im .NET-Ökosystem.

Erste Schritte mit NLog

Wir können NLog in ASP.NET-Webanwendungen, ASP.NET-WEB-APIs, Windows-Form-Anwendungen, ASP.NET-MVC-Anwendungen oder in jeder anderen Art von Anwendungen verwenden, die wir benötigen. Wir werden die Konsolenanwendung verwenden, um alle Anwendungsfälle zu demonstrieren.

NLog Nuget-Paket installieren

Um mit NLog zu beginnen, müssen Sie das NLog NuGet-Paket in Ihrem Projekt installieren. Sie können dies über den NuGet Package Manager in Visual Studio tun, indem Sie die folgenden Schritte ausführen:

1. Wählen Sie im Menü "Tools" die Option "NuGet Package Manager" und dann "Manage NuGet Packages for Solution"

2. Oder klicken Sie mit der rechten Maustaste auf Ihr Projekt im Projektmappen-Explorer, wählen Sie "NuGet-Pakete verwalten" und wählen Sie "Durchsuchen"

3. Klicken Sie im Fenster des NuGet-Paketmanagers auf die Registerkarte "Durchsuchen", und geben Sie in das Suchfeld "NLog" ein

4. Sie sollten das NLog-Paket in den Suchergebnissen sehen. Klicken Sie sie an, um sie auszuwählen.

5. Auf der rechten Seite des Fensters NuGet Package Manager befindet sich eine Liste der Projekte in Ihrer Lösung. Wählen Sie das Projekt(s) wo Sie NLog installieren möchten.

6. Wählen Sie die gewünschte Version des NLog-Pakets aus dem Versions-Dropdown. Sie können die letzte stabile Version oder bei Bedarf eine bestimmte Version auswählen.

7. Nach der Auswahl des Projekts(s) und die Version, klicken Sie auf die Schaltfläche "Installieren", um den Installationsvorgang zu starten.

   Der NuGet Package Manager wird NLog und alle Abhängigkeiten herunterladen und installieren. Sie sehen den Fortschritt im Ausgabefenster.

   NLog ist nun erfolgreich in Ihrem Projekt installiert, und Sie können es für die Protokollierung in Ihrem C#-Code verwenden.

NLog-Konfigurationsdatei erstellen

So erstellen Sie eine NLog-Konfigurationsdatei (typischerweise nlog.config genannt)können Sie die folgenden Schritte ausführen. Diese Konfigurationsdatei legt fest, wie sich NLog in Ihrer Anwendung verhalten soll, einschließlich Protokollziele, Layout-Renderer und Regeln.

Klicken Sie in Ihrem Projekt mit der rechten Maustaste auf das Projekt oder den gewünschten Ordner, in dem Sie die Konfigurationsdatei erstellen möchten.

1. Wählen Sie "Hinzufügen" > "Neuer Artikel..."

2. Suchen Sie im Dialogfeld "Neues Element hinzufügen" nach "XML-Datei" oder "XML" und wählen Sie es aus.

3. Benennen Sie die Datei nlog.config und klicken Sie auf die Schaltfläche "Hinzufügen".

   

4. Öffnen Sie die neu erstellte Datei nlog.config in einem Texteditor oder XML-Editor.

5. Fügen Sie die folgende Konfiguration in die Datei NLog.XML ein. Nachfolgend finden Sie ein einfaches Beispiel für eine NLog-Konfiguration, die Meldungen an ein Konsolenziel protokolliert. Sie können diese Config-Datei an Ihre Bedürfnisse anpassen:

Konfig-Datei

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

Stellen Sie in Ihrem C#-Code sicher, dass Sie die NLog-Konfiguration aus der Datei nlog.config laden. Dies geschieht in der Regel im Startup-Code der Anwendung, z. B. in einer ASP.NET Core Startup.cs(für .NET Version gleich oder älter als .NET 5), Datei program.cs (für .NET 6 oder eine neuere Version) oder die Main-Methode einer Konsolenanwendung:

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

Die Ausgabe des obigen Programms ist wie folgt:

In diesem Beispiel erstellen wir eine Instanz der Klasse Logger und verwenden sie zur Protokollierung von Meldungen auf der Debug-Ebene. Sehen wir uns die von NLog unterstützte Verfolgungsebene an.

Logging Levels

NLog unterstützt mehrere Protokollierungsebenen, jede mit ihrer eigenen Bedeutung:

1. Verfolgung: Die detaillierteste Ebene, die normalerweise für Diagnosezwecke verwendet wird.

2. Fehlersuche: Wird für Debugging-Informationen verwendet, die während der Entwicklung hilfreich sein können.

3. Info: Allgemeine Informationen über den Betrieb der Anwendung.

4. Warnen: Weist auf ein mögliches Problem hin, das die Anwendung nicht stört.

5. Fehler: Zeigt einen Fehler an, der untersucht werden sollte, aber nicht unbedingt zum Absturz der Anwendung führt.

6. Fatal: Weist auf einen kritischen Fehler hin, der sofort behoben werden sollte.

   Durch die Kategorisierung von Protokollmeldungen in diese Stufen können Sie sie leicht filtern und nach ihrem Schweregrad priorisieren.

   Setzen Sie minlevel="Trace" im rules-Tag in Ihrer nLog.Config-Datei wie unten gezeigt.

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

Schreiben wir einen Code zur Protokollierung der Meldungen aller Verfolgungsebenen.

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

Unser Programm hat Meldungen in der Konsole protokolliert, wie unten dargestellt.

Jetzt haben wir das Beispiel der Protokollierung von Nachrichten in der Konsole demonstriert, jetzt werden wir NLog target konfigurieren, um Nachrichten in der Datei zu protokollieren.

Logmeldung in Datei

Wir müssen in unserer Konfigurationsdatei für die Dateiprotokollierung ein Dateiziel anstelle eines Konsolenziels festlegen.

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

Führen Sie nun das Programm aus, um die Meldungen in einer Datei zu protokollieren.

Protokollierungsziele

NLog unterstützt verschiedene Ziele für die Protokollausgabe, so dass Sie wählen können, wo Ihre Protokollnachrichten gespeichert werden sollen. Einige häufige Ziele sind:

1. Datei: Protokolliert Meldungen in einer oder mehreren Dateien.

2. Konsole: Protokolliert Meldungen auf der Konsole.

3. Datenbank: Protokolliert Meldungen in einer Datenbank (SQL Server, MySQL, Oracle, PostgreSQL, usw.) tisch.

4. E-Mail: Sendet Protokollmeldungen als E-Mail.

5. Ereignisprotokoll: Protokolliert Meldungen im Windows-Ereignisprotokoll.

6. Benutzerdefinierte Ziele: Sie können benutzerdefinierte Protokollziele erstellen, die Ihren speziellen Anforderungen entsprechen.

   Sie können NLog so konfigurieren, dass es ein oder mehrere Ziele gleichzeitig verwendet.

IronPDF stellt sich vor

IronPDF ist eine leistungsstarke .NET-Bibliothek, die die PDF-Verarbeitung in C#- und VB.NET-Anwendungen vereinfacht. Es bietet robuste Funktionen für die Erstellung, Bearbeitung und Manipulation von PDF-Dokumenten sowie für die Konvertierung von HTML-Inhalten in das PDF-Format und ist damit ein unverzichtbares Werkzeug für Entwickler in einer Vielzahl von Branchen, darunter Webentwicklung, Berichtswesen und Dokumentenmanagement.

IronPDFs herausragendes Merkmal ist seine HTML zu PDF funktion, mit der Ihre Layouts und Stile erhalten bleiben. Es generiert PDFs aus Webinhalten und ist damit ideal für Berichte, Rechnungen und Dokumentationen. HTML-Dateien, URLs und HTML-Strings können problemlos in PDFs umgewandelt werden.

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

Lassen Sie uns ein PDF mit Protokollierung erstellen.

PDF-Erzeugung mit Protokollierung

Der erste Schritt besteht darin, die IronPDF-Bibliothek in unserem Projekt zu installieren. Wir können dies mit dem NuGet Package Manager in Visual Studio oder über die NuGet CLI tun. Öffnen Sie Ihr Projekt und schreiben Sie den folgenden Befehl in die Paketmanager-Konsole.

Install-Package IronPdf

Mit diesem Befehl wird IronPDF mit allen erforderlichen Abhängigkeiten in unserem Projekt installiert.

Schreiben Sie den folgenden Code, um eine PDF-Datei aus HTML mit Protokollierung zu erzeugen.

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

Das obige Codeschnipsel erstellt eine PDF-Datei mit einer protokollierten Nachricht in der Datei, wie unten gezeigt.

Protokoll und PDF-Datei

Fazit

Zusammenfassend lässt sich sagen, dass NLog sich zu einem unverzichtbaren Werkzeug für die effektive Protokollierung in C#-Anwendungen entwickelt hat und Entwicklern ein robustes Framework für die Erfassung, Kategorisierung und Verwaltung von Protokolldaten bietet. Seine Flexibilität und Benutzerfreundlichkeit machen es zur ersten Wahl für Protokollierungsanforderungen in verschiedenen Bereichen. In Kombination mit ergänzenden Bibliotheken wie IronPDF, die die PDF-Erzeugung und -Bearbeitung in .NET-Anwendungen vereinfachen, können Entwickler ihre Verwaltungsfunktionen um die Erstellung von PDF-basierten Protokollen und Berichten erweitern. Es ist erwähnenswert, dass IronPDF Folgendes bietet einen kostenlosen Test um seine Funktionen zu testen. Wenn es Ihren Anforderungen entspricht, können Sie sich für eine handelslizenzdamit haben Sie weiterhin Zugang zu den Möglichkeiten von IronPDF mit zusätzlichen Vorteilen und Unterstützung für eine nahtlose Integration in Ihre Projekte, insbesondere für PDF-bezogene Funktionen.

Durch den gemeinsamen Einsatz von NLog und IronPDF können Entwickler nicht nur Einblicke in das Verhalten ihrer Anwendungen gewinnen, sondern auch ihre Berichterstattungs- und Dokumentenverwaltungsprozesse verbessern und so sicherstellen, dass ihre Software effizient, wartbar und mit einer gut dokumentierten strukturierten Protokollierung versehen bleibt.