Logging ist ein wesentlicher Aspekt der Softwareentwicklung. Es hilft Entwicklern, das Verhalten ihrer Anwendungen zu verfolgen, Probleme zu beheben und Einblicke darüber zu gewinnen, wie ihr Code in verschiedenen Umgebungen funktioniert. NLog ist ein beliebtes Logging-Framework für C#, das es einfach macht, robustes und flexibles Logging in Ihre Anwendungen zu implementieren. In diesem umfassenden Leitfaden und Tutorial werden wir die Welt von NLog in C# erkunden.

Was ist NLog?

NLog ist eine kostenlose, Open-Source-Logging-Bibliothek für .NET und .NET Core-Anwendungen. Es bietet eine flexible und hoch konfigurierbare Möglichkeit, Nachrichten in Ihrer Anwendung zu protokollieren. NLog ist eine weit verbreitete, kostenlose Logging-Plattform im .NET-Ökosystem aufgrund seiner Leistung, Erweiterbarkeit und Benutzerfreundlichkeit.

Einstieg mit NLog

Wir können NLog in ASP.NET-Webanwendungen, ASP.NET WEB-APIs, Windows Forms-Anwendungen, ASP.NET MVC-Anwendungen oder jeder anderen Art gemäß unseren Anforderungen verwenden. 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-Paket-Manager in Visual Studio tun, indem Sie folgende Schritte ausführen:

1. Wählen Sie im Menü "Tools" den Punkt "NuGet-Paket-Manager" und dann "NuGet-Pakete für die Lösung verwalten".
2. Oder klicken Sie mit der rechten Maustaste auf Ihr Projekt im Lösungsexplorer, wählen "NuGet-Pakete verwalten" und wählen "Durchsuchen".
3. Klicken Sie im Fenster des NuGet-Paket-Managers auf die Registerkarte "Durchsuchen" und geben Sie im Suchfeld "NLog" ein.
4. Sie sollten das NLog-Paket in den Suchergebnissen sehen. Klicken Sie darauf, um auszuwählen.
5. Auf der rechten Seite des Fensters des NuGet-Paket-Managers gibt es eine Liste der Projekte in Ihrer Lösung. Wählen Sie das/die Projekt(e) aus, in denen Sie NLog installieren möchten.
6. Wählen Sie die gewünschte Version des NLog-Pakets aus dem Dropdown-Menü aus. Sie können die neueste stabile Version oder eine spezifische Version auswählen, falls erforderlich.
7. Nachdem Sie das/die Projekt(e) und die Version ausgewählt haben, klicken Sie auf die Schaltfläche "Installieren", um den Installationsprozess zu starten.

Der NuGet-Paket-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 sofort für das Logging in Ihrem C#-Code verwenden.

NLog-Konfigurationsdatei erstellen

Um eine NLog-Konfigurationsdatei zu erstellen (normalerweise nlog.config genannt), können Sie folgende Schritte ausführen. Diese Konfigurationsdatei gibt an, wie sich NLog in Ihrer Anwendung verhalten soll, einschließlich der Log-Ziele, 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" > "Neues Element..."
2. Suchen Sie im Dialogfeld "Neues Element hinzufügen" nach "XML-Datei" oder "XML" und wählen Sie es aus.
3. Nennen Sie die Datei nlog.config und klicken Sie auf 'Hinzufügen'.

4. Öffnen Sie die neu erstellte nlog.config-Datei in einem Texteditor oder XML-Editor.
5. Fügen Sie die folgende Konfiguration in die NLog.XML-Datei ein. Nachfolgend ein einfaches Beispiel für eine NLog-Konfiguration, die Nachrichten an ein Konsolen-Ziel protokolliert. Sie können diese Konfigurationsdatei an Ihre Bedürfnisse anpassen:

Konfigurationsdatei

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

In Ihrem C#-Code stellen Sie sicher, dass Sie die NLog-Konfiguration aus der nlog.config-Datei laden. Dies erfolgt in der Regel im Startcode der Anwendung, beispielsweise in einer ASP.NET Core Startup.cs (for .NET-Version gleich oder älter als .NET 5), program.cs-Datei (for .NET 6 oder spätere Version) oder der Main-Methode einer Konsolenanwendung:

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

Die Ausgabe des obigen Programms wird wie folgt angezeigt:

In diesem Beispiel erstellen wir eine Instanz der Logger-Klasse und verwenden sie, um Nachrichten auf Debug-Ebene zu protokollieren. Lassen Sie uns die von NLog unterstützte Überwachungsebene erkunden.

Protokollierungsebenen

NLog unterstützt mehrere Logging-Ebenen, von denen jede ihre eigene Bedeutung hat:

1. Trace: Die detaillierteste Ebene, typischerweise für Diagnosezwecke verwendet.
2. Debug: 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. Warn: Weist auf ein potenzielles Problem hin, das die Anwendung nicht beeinträchtigt.
5. Error: Weist auf einen Fehler hin, der untersucht werden sollte, aber nicht unbedingt die Anwendung zum Absturz bringt.
6. Fatal: Weist auf einen kritischen Fehler hin, der sofort behoben werden sollte.

Indem Sie die Log-Nachrichten in diese Ebenen kategorisieren, können Sie sie basierend auf ihrer Schwere leicht filtern und 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>

Lassen Sie uns Code zum Protokollieren aller Überwachungsebenen schreiben.

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

Unser Programm hat die Nachrichten in der Konsole wie unten gezeigt protokolliert.

Jetzt haben wir das Beispiel des Loggens von Nachrichten in die Konsole demonstriert. Jetzt werden wir ein NLog-Ziel konfigurieren, um Nachrichten in eine Datei zu protokollieren.

Protokollnachricht in Datei

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

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

Führen Sie das Programm aus, um Nachrichten in eine Datei zu protokollieren.

Ziele der Protokollierung

NLog unterstützt verschiedene Log-Ausgabeziele, die es Ihnen ermöglichen, auszuwählen, wo Ihre Log-Nachrichten gespeichert werden sollen. Einige gängige Ziele umfassen:

1. Datei: Protokolliert Nachrichten in eine oder mehrere Dateien.
2. Konsole: Protokolliert Nachrichten auf der Konsole.
3. Datenbank: Protokolliert Nachrichten in einer Datenbanktabelle (SQL Server, MySQL, Oracle, PostgreSQL, etc.).
4. E-Mail: Sendet Log-Nachrichten als E-Mails.
5. Ereignisprotokoll: Protokolliert Nachrichten im Windows-Ereignisprotokoll.
6. Benutzerdefinierte Ziele: Sie können benutzerdefinierte Protokollziele erstellen, um Ihren spezifischen Anforderungen gerecht zu werden.

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

Einführung in IronPDF

Mehr über IronPDF erfahren ist eine leistungsstarke .NET-Bibliothek, die das Arbeiten mit PDFs in C#- und VB.NET-Anwendungen vereinfacht. Es bietet robuste Funktionen zum Erstellen, Bearbeiten und Manipulieren von PDF-Dokumenten sowie zum Konvertieren von HTML-Inhalten in das PDF-Format, was es zu einem unverzichtbaren Werkzeug für Entwickler in einer Vielzahl von Branchen macht, darunter Webentwicklung, Berichterstellung und Dokumentenmanagement.

IronPDF's herausragende Funktion ist seine HTML-zu-PDF-Konvertierung-Funktion, die Ihre Layouts und Stile bewahrt. Es generiert PDFs aus Web-Inhalten und ist ideal für Berichte, Rechnungen und Dokumentationen. HTML-Dateien, URLs und HTML-Strings können problemlos in PDFs konvertiert 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

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

Let's generate a PDF with logging.

PDF-Erzeugung mit Protokollierung

Der erste Schritt ist, die IronPDF-Bibliothek in unser Projekt zu installieren. Das können wir über den NuGet-Paket-Manager in Visual Studio oder über die NuGet-CLI tun. Öffnen Sie Ihr Projekt und schreiben Sie den folgenden Befehl in die Paket-Manager-Konsole.

Install-Package IronPdf

Dieser Befehl wird IronPDF mit allen erforderlichen Abhängigkeiten in unserem Projekt installieren.

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

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

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

Protokoll und PDF-Datei

Abschluss

Zusammenfassend hat sich NLog als ein wesentliches Werkzeug für effektives Logging in C#-Anwendungen erwiesen, indem es Entwicklern ein robustes Framework zum Erfassen, Kategorisieren und Verwalten von Log-Daten bietet. Seine Flexibilität und Benutzerfreundlichkeit machen es zu einer bevorzugten Wahl für Log-Anforderungen in verschiedenen Bereichen. Darüber hinaus können Entwickler in Kombination mit ergänzenden Bibliotheken wie IronPDF, die die PDF-Erstellung und -Bearbeitung in .NET-Anwendungen vereinfachen, ihre Managementfähigkeiten auf die Erstellung von PDF-basierten Logs und Berichten erweitern. Es ist erwähnenswert, dass IronPDF eine kostenlose Testversion von IronPDF zum Testen seiner Funktionen bietet. Wenn es Ihre Anforderungen erfüllt, können Sie eine kommerzielle Lizenz für IronPDF erwerben, die Ihnen fortlaufenden Zugriff auf die Fähigkeiten von IronPDF mit zusätzlichen Vorteilen und Unterstützung für eine nahtlose Integration in Ihre Projekte bietet, insbesondere für PDF-bezogene Funktionalitäten.

Durch den Einsatz der Leistung von NLog und IronPDF zusammen können Entwickler nicht nur Einblicke in das Verhalten ihrer Anwendung gewinnen, sondern auch ihre Berichts- und Dokumentenmanagementprozesse verbessern und sicherstellen, dass ihre Software effizient, wartbar und gut dokumentiert bleibt, strukturiertes Logging.