Konsolenanwendungen erfordern trotz fehlender grafischer Benutzeroberfläche häufig robuste Protokollierungsmechanismen, um Fehler zu verfolgen, die Anwendungsleistung zu überwachen und Probleme effizient zu debuggen. Prism.Plugin.Logging, eine Erweiterung des Prism Logging Frameworks, bietet eine umfassende Protokollierungslösung for .NET-Anwendungen, einschließlich Unterstützung für verschiedene Logdienstanbieter.

In diesem Artikel untersuchen wir, wie man Prism Logging in Konsolenanwendungen mit IronPDF, einer leistungsstarken .NET-Bibliothek zur Arbeit mit PDF-Dokumenten, integriert. Durch die Kombination dieser Werkzeuge können Entwickler erweiterte Protokollierungsfunktionen in ihren Konsolenanwendungen implementieren, was die Wartbarkeit und Fehlerbehebung verbessert.

Einführung in die Prism-Protokollierung

Prism.Plugin.Logging erweitert Prism, ein beliebtes Framework zum Erstellen von XAML-Anwendungen, indem es umfassende Protokollierungskapazitäten bereitstellt. #### Beispiel mit beiden Schritten

Vorteile der Verwendung von Prism Logging

Flexible Logkonfiguration: Prism.Plugin.Logging ermöglicht es Entwicklern, verschiedene Loganbieter nahtlos zu konfigurieren, einschließlich beliebter Optionen wie NLog, Serilog und Microsoft.Extensions.Logging.

Strukturierte Logunterstützung: Entwickler können strukturierten Daten mit ihren Nachrichten unter Verwendung von Prism.Plugin.Logging protokollieren. Diese Funktion ist besonders hilfreich in Szenarien mit Konsolenanwendungen, bei denen umfassende Kontextdaten, einschließlich Zeitstempel, Fehlercodes oder Benutzeraktivitäten, aufgezeichnet und den von IronPDF erstellten Logberichten hinzugefügt werden müssen.

Verwendung der Prism-Protokollierung

1. Erstellen Sie ein neues C#-Projekt
2. Installieren Sie das Prism-Logging-Paket.
3. Erstellen Sie ein Objekt für den SyslogLogger und übergeben Sie die Konfiguration als Parameter.
4. Rufen Sie die Logmethode bei Bedarf auf und übergeben Sie die Lognachricht und das Loglevel.
5. Löschen Sie das Logobjekt am Ende.

Einstieg mit Prism Logs

Setting up Prism in C# Projects

Die Integration von Prism in ein C#-Projekt ist einfach. Die Nutzung von NuGet, dem .NET-Paketmanager von Microsoft, ist erforderlich, um Prism hinzuzufügen. Die Werkzeuge und Bibliotheken, die benötigt werden, um Prism Logs in Ihre Projekte zu integrieren, werden von dieser Bibliothek bereitgestellt.

Implementierung von Prism in Dot.NET-Anwendungen

Prism ist mit verschiedenen Dot .NET-Anwendungstypen kompatibel, einschließlich Windows Forms (WinForms) und Windows Console. Obwohl jedes Framework anders implementiert ist, bleibt das Grundkonzept das gleiche und hilft uns, die datenbezogenen Daten Ihrer Anwendung zu protokollieren.

Erstellen eines neuen Projekts in Visual Studio

Wählen Sie das Menü "Datei" in der Visual Studio-Anwendung. Klicken Sie auf "Neues Projekt", wählen Sie dann "Konsolenanwendung".

Geben Sie den Projektnamen im vorgesehenen Textbereich ein, nachdem Sie den Dateispeicherort ausgewählt haben. Wählen Sie dann, wie unten gezeigt, das erforderliche .NET Framework, indem Sie auf die Schaltfläche "Erstellen" klicken.

Die gewählte Anwendung wird dann bestimmen, wie das Visual Studio-Projekt organisiert ist. Öffnen Sie einfach die Datei program.cs, um mit dem Hinzufügen von Code zur Anwendung zu beginnen und diese zu erstellen. Sie können Windows, die Konsole oder die Webanwendung nutzen.

Danach kann die Bibliothek hinzugefügt und der Code getestet werden.

Ein grundlegendes Beispiel für die Verwendung von Prism Logs

Im untenstehenden Codebeispiel initialisieren wir das Prism-Logobjekt und fügen dann nacheinander verschiedene Loglevels zu den Prism-Logs hinzu und speichern alle Logs und deren Wichtigkeit in einer Liste.

using Prism.Logging.Syslog;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

class Program
{
    public class Demo
    {
        public string Name { get; set; }
        public int Age { get; set; }

        // Configure the logger options
        static Options genOptions = new Options
        {
            HostNameOrIp = "127.0.0.1",
            Port = 514,
            AppNameOrTag = "LoggingDemo"
        };

        static SyslogLogger logger = new SyslogLogger(genOptions);
        static IList<LogData> Loglst = new List<LogData>();

        static async Task Main(string[] args)
        {
            MessageLog("Application started.", Prism.Logging.Syslog.Level.Information);
            PerformApplicationLogic();
            MessageLog("Application stopped.", Prism.Logging.Syslog.Level.Information);
        }

        static void PerformApplicationLogic()
        {
            // Example application logic
            Console.WriteLine("Performing application logic...");

            // Simulate error
            try
            {
                throw new Exception("Simulated Exception");
            }
            catch (Exception ex)
            {
                MessageLog($"Error occurred: {ex.Message}", Prism.Logging.Syslog.Level.Error);
            }
        }

        // Logs messages and their levels
        static void MessageLog(string message, Prism.Logging.Syslog.Level level)
        {
            Loglst.Add(new LogData { Message = message, Level = level.ToString() });
            logger.Log(message, level);
        }

        public class LogData
        {
            public string Message { get; set; }
            public string Level { get; set; }
        }

        public class Options : ISyslogOptions
        {
            public string HostNameOrIp { get; set; }
            public int? Port { get; set; }
            public string AppNameOrTag { get; set; }
        }
    }
}

using Prism.Logging.Syslog;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

class Program
{
    public class Demo
    {
        public string Name { get; set; }
        public int Age { get; set; }

        // Configure the logger options
        static Options genOptions = new Options
        {
            HostNameOrIp = "127.0.0.1",
            Port = 514,
            AppNameOrTag = "LoggingDemo"
        };

        static SyslogLogger logger = new SyslogLogger(genOptions);
        static IList<LogData> Loglst = new List<LogData>();

        static async Task Main(string[] args)
        {
            MessageLog("Application started.", Prism.Logging.Syslog.Level.Information);
            PerformApplicationLogic();
            MessageLog("Application stopped.", Prism.Logging.Syslog.Level.Information);
        }

        static void PerformApplicationLogic()
        {
            // Example application logic
            Console.WriteLine("Performing application logic...");

            // Simulate error
            try
            {
                throw new Exception("Simulated Exception");
            }
            catch (Exception ex)
            {
                MessageLog($"Error occurred: {ex.Message}", Prism.Logging.Syslog.Level.Error);
            }
        }

        // Logs messages and their levels
        static void MessageLog(string message, Prism.Logging.Syslog.Level level)
        {
            Loglst.Add(new LogData { Message = message, Level = level.ToString() });
            logger.Log(message, level);
        }

        public class LogData
        {
            public string Message { get; set; }
            public string Level { get; set; }
        }

        public class Options : ISyslogOptions
        {
            public string HostNameOrIp { get; set; }
            public int? Port { get; set; }
            public string AppNameOrTag { get; set; }
        }
    }
}

Imports Prism.Logging.Syslog
Imports System
Imports System.Collections.Generic
Imports System.Threading.Tasks

Friend Class Program
	Public Class Demo
		Public Property Name() As String
		Public Property Age() As Integer

		' Configure the logger options
		Private Shared genOptions As New Options With {
			.HostNameOrIp = "127.0.0.1",
			.Port = 514,
			.AppNameOrTag = "LoggingDemo"
		}

		Private Shared logger As New SyslogLogger(genOptions)
		Private Shared Loglst As IList(Of LogData) = New List(Of LogData)()

		Shared Async Function Main(ByVal args() As String) As Task
			MessageLog("Application started.", Prism.Logging.Syslog.Level.Information)
			PerformApplicationLogic()
			MessageLog("Application stopped.", Prism.Logging.Syslog.Level.Information)
		End Function

		Private Shared Sub PerformApplicationLogic()
			' Example application logic
			Console.WriteLine("Performing application logic...")

			' Simulate error
			Try
				Throw New Exception("Simulated Exception")
			Catch ex As Exception
				MessageLog($"Error occurred: {ex.Message}", Prism.Logging.Syslog.Level.Error)
			End Try
		End Sub

		' Logs messages and their levels
		Private Shared Sub MessageLog(ByVal message As String, ByVal level As Prism.Logging.Syslog.Level)
			Loglst.Add(New LogData With {
				.Message = message,
				.Level = level.ToString()
			})
			logger.Log(message, level)
		End Sub

		Public Class LogData
			Public Property Message() As String
			Public Property Level() As String
		End Class

		Public Class Options
			Implements ISyslogOptions

			Public Property HostNameOrIp() As String
			Public Property Port() As Integer?
			Public Property AppNameOrTag() As String
		End Class
	End Class
End Class

Imports Prism.Logging.Syslog
Imports System
Imports System.Collections.Generic
Imports System.Threading.Tasks

Friend Class Program
	Public Class Demo
		Public Property Name() As String
		Public Property Age() As Integer

		' Configure the logger options
		Private Shared genOptions As New Options With {
			.HostNameOrIp = "127.0.0.1",
			.Port = 514,
			.AppNameOrTag = "LoggingDemo"
		}

		Private Shared logger As New SyslogLogger(genOptions)
		Private Shared Loglst As IList(Of LogData) = New List(Of LogData)()

		Shared Async Function Main(ByVal args() As String) As Task
			MessageLog("Application started.", Prism.Logging.Syslog.Level.Information)
			PerformApplicationLogic()
			MessageLog("Application stopped.", Prism.Logging.Syslog.Level.Information)
		End Function

		Private Shared Sub PerformApplicationLogic()
			' Example application logic
			Console.WriteLine("Performing application logic...")

			' Simulate error
			Try
				Throw New Exception("Simulated Exception")
			Catch ex As Exception
				MessageLog($"Error occurred: {ex.Message}", Prism.Logging.Syslog.Level.Error)
			End Try
		End Sub

		' Logs messages and their levels
		Private Shared Sub MessageLog(ByVal message As String, ByVal level As Prism.Logging.Syslog.Level)
			Loglst.Add(New LogData With {
				.Message = message,
				.Level = level.ToString()
			})
			logger.Log(message, level)
		End Sub

		Public Class LogData
			Public Property Message() As String
			Public Property Level() As String
		End Class

		Public Class Options
			Implements ISyslogOptions

			Public Property HostNameOrIp() As String
			Public Property Port() As Integer?
			Public Property AppNameOrTag() As String
		End Class
	End Class
End Class

Prism Logging generiert Logberichte. Wir verwenden ein Tool namens Kiwi Syslog Service Manager, um die Prism-Logs zu überwachen.

Prisma-Protokolldatei ausgeben

Prism Logs Operationen

Erweiterbare Protokollierung

Die Funktionen von Prism.Plugin.Logging werden durch Protokollierung erweitert, was mehr Funktionalität und Flexibilität bietet. Es bietet eine Reihe von Konfigurationsoptionen, um Logebenen, Logziele und andere Variablen an die Loganforderungen Ihrer Anwendung anzupassen.

Mehrere Log-Ziele

Mit Prism.Plugin.Logging können Sie Lognachrichten an verschiedene Orte senden, einschließlich der Konsole, Dateien, Datenbanken und anderen Loggingdiensten. Dank dieser Flexibilität können Sie die besten Protokollierungsziele für die Anforderungen und die Umgebung Ihrer Anwendung auswählen.

Benutzerdefinierte Logger

Mit dem Plugin können Sie das ILoggerFacade-Interface von Prism implementieren, um benutzerdefinierte Logger zu erstellen. So können Sie benutzerdefinierte Protokollierungsfunktionen basierend auf den Bedürfnissen Ihrer Anwendung erstellen oder sich mit Drittanbieter-Logging-Frameworks integrieren.

Protokoll mit Prism Logs erstellen

Prism-Logs können einfach mit wenigen Codezeilen erstellt werden. Unten ist das Beispiel, um ein Log zu erstellen.

static Options genOptions = new Options
{
    HostNameOrIp = "127.0.0.1",
    Port = 514,
    AppNameOrTag = "LoggingDemo"
};
static SyslogLogger logger = new SyslogLogger(genOptions);
logger.Log("Sample message", Prism.Logging.Syslog.Level.Information);

static Options genOptions = new Options
{
    HostNameOrIp = "127.0.0.1",
    Port = 514,
    AppNameOrTag = "LoggingDemo"
};
static SyslogLogger logger = new SyslogLogger(genOptions);
logger.Log("Sample message", Prism.Logging.Syslog.Level.Information);

Private Shared genOptions As New Options With {
	.HostNameOrIp = "127.0.0.1",
	.Port = 514,
	.AppNameOrTag = "LoggingDemo"
}
Private Shared logger As New SyslogLogger(genOptions)
logger.Log("Sample message", Prism.Logging.Syslog.Level.Information)

Private Shared genOptions As New Options With {
	.HostNameOrIp = "127.0.0.1",
	.Port = 514,
	.AppNameOrTag = "LoggingDemo"
}
Private Shared logger As New SyslogLogger(genOptions)
logger.Log("Sample message", Prism.Logging.Syslog.Level.Information)

Integration von Prism Logging und IronPDF

Prisma und IronPDF gemeinsam verwenden

Die Kombination von Prism mit IronPDF in einem C#-Projekt eröffnet einige spannende Möglichkeiten. IronPDF ist ein fantastisches Werkzeug, um diesen Inhalt in PDFs umzuwandeln, obwohl Prism ein großartiges Werkzeug zur Arbeit mit Logs ist. Programmierer können Apps erstellen, die den Artikel in ein benutzerdefiniertes PDF-Dokument loggen, dank dieser Konnektivität.

Prism-Protokollierung mit IronPDF

Durch das Erstellen einer Windows-Konsolenanwendung, die Prism-Logs verwendet, können Nutzer mit den Logs innerhalb Ihres Programms interagieren. Diese Steuerung sollte auf der Konsole mit viel Platz für Logs passen. Fügen Sie Serverprotokolloperationen und HTTP-Logs hinzu.

IronPDF installieren

• Öffnen Sie das Visual Studio-Projekt.

• Wählen Sie "Tools" > "NuGet-Paket-Manager" > "Paket-Manager-Konsole".

  • Geben Sie im Paketmanager-Konsolenfenster den folgenden Befehl ein und drücken Sie Enter:

    PM > Install-Package IronPdf

• Eine andere Möglichkeit, IronPDF zu installieren, ist die Nutzung des "NuGet Package Manager for Solutions".

• Durchsuchen Sie das IronPDF-Paket in den Suchergebnissen, wählen Sie es aus, und klicken Sie dann auf die Schaltfläche "Installieren". Visual Studio kümmert sich automatisch um den Download und die Installation.

• NuGet lädt und installiert das IronPDF-Paket und alle Abhängigkeiten, die für Ihr Projekt erforderlich sind.
• Sobald IronPDF installiert ist, können Sie es in Ihrem Projekt verwenden.

Installation über die NuGet-Website

Besuchen Sie die IronPDF-Seite unter https://www.nuget.org/packages/IronPdf auf der NuGet-Website, um mehr über die Funktionen, die Kompatibilität und andere Download-Optionen von IronPDF zu erfahren.

DLL zum Installieren verwenden

Alternativ können Sie IronPDF direkt in Ihr Projekt integrieren, indem Sie seine DLL-Datei verwenden. Um die ZIP-Datei mit der DLL herunterzuladen, klicken Sie auf diesen Link. Sobald es entpackt wurde, fügen Sie die DLL in Ihr Projekt ein.

Implementierung der Logik

• Einrichten des Renderers und Loggers: Die Software richtet den IronPDF-Renderer und den Prism-Logger ein.
• Protokollierung von Meldungen: Meldungen mit einer festgelegten Kategorie und Priorität können mithilfe der Methode MessageLog() protokolliert werden. In diesem Beispiel protokollieren wir die Start- und Endnachrichten der Anwendung sowie alle Ausnahmen, die während der Ausführung der Anwendung auftreten.
• Anwenden der Logik: Ein Teil der Anwendungslogik wird durch die Methode PerformApplicationLogic() simuliert. Um die Fehlerprotokollierung zu veranschaulichen, erzeugt sie lediglich eine Nachricht und löst in diesem Fall eine Ausnahme aus.
• Erstellen eines PDF-Logberichts: Nach der Ausführung der Anwendungslogik erstellt die Software ein HTML-Dokument basierend auf den aufgezeichneten Nachrichten. Dann verwendet es die IronPDF-Funktion RenderHtmlAsPdf(), um das HTML-Dokument in eine Logdatei als PDF-Bericht zu transformieren. Die PDF-Datei wird dann auf die Festplatte gespeichert.

Erweiterung des zuvor definierten Codes, um IronPDF-Code zu integrieren:

using IronPdf;

static void GeneratePdfLogReport()
{
    var renderer = new ChromePdfRenderer(); // Instantiates Chrome Renderer

    // Generate HTML content for PDF report
    string htmlContent = "<h1>Log Report</h1><ul>";
    foreach (var log in Loglst)
    {
        htmlContent += $"<li><strong>Message: {log.Message}</strong> Level: {log.Level}</li>";
    }
    htmlContent += "</ul>";
    
    // Generate PDF document
    var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

    // Save PDF file
    string filePath = "log_report.pdf";
    pdfDocument.SaveAs(filePath);
    Console.WriteLine($"PDF log report generated: {filePath}");
}

using IronPdf;

static void GeneratePdfLogReport()
{
    var renderer = new ChromePdfRenderer(); // Instantiates Chrome Renderer

    // Generate HTML content for PDF report
    string htmlContent = "<h1>Log Report</h1><ul>";
    foreach (var log in Loglst)
    {
        htmlContent += $"<li><strong>Message: {log.Message}</strong> Level: {log.Level}</li>";
    }
    htmlContent += "</ul>";
    
    // Generate PDF document
    var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

    // Save PDF file
    string filePath = "log_report.pdf";
    pdfDocument.SaveAs(filePath);
    Console.WriteLine($"PDF log report generated: {filePath}");
}

Imports IronPdf

Private Shared Sub GeneratePdfLogReport()
    Dim renderer = New ChromePdfRenderer() ' Instantiates Chrome Renderer

    ' Generate HTML content for PDF report
    Dim htmlContent As String = "<h1>Log Report</h1><ul>"
    For Each log In Loglst
        htmlContent += $"<li><strong>Message: {log.Message}</strong> Level: {log.Level}</li>"
    Next
    htmlContent += "</ul>"

    ' Generate PDF document
    Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)

    ' Save PDF file
    Dim filePath As String = "log_report.pdf"
    pdfDocument.SaveAs(filePath)
    Console.WriteLine($"PDF log report generated: {filePath}")
End Sub

Imports IronPdf

Private Shared Sub GeneratePdfLogReport()
    Dim renderer = New ChromePdfRenderer() ' Instantiates Chrome Renderer

    ' Generate HTML content for PDF report
    Dim htmlContent As String = "<h1>Log Report</h1><ul>"
    For Each log In Loglst
        htmlContent += $"<li><strong>Message: {log.Message}</strong> Level: {log.Level}</li>"
    Next
    htmlContent += "</ul>"

    ' Generate PDF document
    Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)

    ' Save PDF file
    Dim filePath As String = "log_report.pdf"
    pdfDocument.SaveAs(filePath)
    Console.WriteLine($"PDF log report generated: {filePath}")
End Sub

Unten ist der Bild-Logbericht, der von IronPDF erstellt wurde

Um mehr über die IronPDF-Code-Referenzen zu erfahren, schauen Sie bitte hier.

Abschluss

Prism.Plugin.Logging-Integration mit IronPDF ermöglicht es Entwicklern, umfassende Protokollierungsfunktionen einfach in Terminal-Apps zu integrieren. Entwickler können die allgemeine Programmwartung verbessern, die Debugging-Funktionen optimieren und die Protokollierungsoperationen beschleunigen, indem sie die Funktionen beider Tools nutzen. Prism.Plugin.Logging ermöglicht es Konsolenanwendungen, eine vollständige Protokollabdeckung zu erhalten und dabei starke Überwachungs- und Fehlerbehebungsfähigkeiten zu gewährleisten, mit der richtigen Implementierung und Einrichtung.

IronPDF bietet eine unbefristete Lizenz von einem Lite bundle, die eine permanente Lizenz, ein Jahr Software-Wartung und ein Upgrade der Bibliothek umfasst. IronPDF bietet für Entwicklungszwecke kostenlose Lizenzen, unterliegt jedoch Einschränkungen hinsichtlich Zeit und Weiterverteilung. Um die kostenlose Testversion zu erwerben. Um mehr über die verschiedenen Iron Software-Produkte zu erfahren, besuchen Sie bitte den Website-Link.