Prism-Protokollierung (So funktioniert es für Entwickler)

Konsolenanwendungen benötigen trotz des Fehlens einer grafischen Benutzeroberfläche oft robuste Protokollierungsmechanismen, um Fehler zu verfolgen, die Anwendungsleistung zu überwachen und Probleme effizient zu beheben. Prism.Plugin.Logging, eine Erweiterung des Prism Logging-Frameworks, bietet eine umfassende Protokollierungslösung für .NET-Anwendungen, einschließlich Unterstützung für verschiedene Protokollierungsanbieter.

In diesem Artikel erfahren Sie, wie Sie Prism Logging in Konsolenanwendungen integrieren können, indem Sie IronPDFeine leistungsstarke .NET-Bibliothek für die Arbeit mit PDF-Dokumenten. Durch die Kombination dieser Tools können Entwickler erweiterte Protokollierungsfunktionen in ihre Konsolenanwendungen implementieren und so die Wartungs- und Fehlerbehebungsmöglichkeiten verbessern.

Einführung in die Prism-Protokollierung

Prism.Plugin.Logging erweitert Prism, ein beliebtes Framework zur Erstellung von XAML-Anwendungen, um umfassende Protokollierungsfunktionen. Mit der Unterstützung für mehrere Protokollierungsanbieter wie NLog, Serilog und Microsoft.Extensions.Logging bietet Prism.Plugin.Logging Flexibilität und Anpassungsmöglichkeiten für verschiedene Anwendungsanforderungen.

Vorteile der Prism-Protokollierung

Flexible Protokollierungskonfiguration: Prism.Plugin.Logging ermöglicht Entwicklern die nahtlose Konfiguration verschiedener Protokollierungsanbieter, einschließlich beliebter Optionen wie NLog, Serilog und Microsoft.Extensions.Logging.

Unterstützung für strukturierte Protokollierung: Entwickler können strukturierte Daten mit ihren Nachrichten protokollieren, indem sie Prism.Plugin.Logging. Diese Funktion ist besonders hilfreich in Szenarien mit Konsolenanwendungen, in denen umfassende Kontextdaten, einschließlich Zeitstempel, Fehlercodes oder Benutzeraktivitäten, aufgezeichnet und den von IronPDF erstellten Protokollberichten hinzugefügt werden müssen.

So verwenden Sie die Prism-Protokollierung

1. Erstellen Sie ein neues C#-Projekt

2. Installieren Sie das Prism-Protokollierungspaket.

3. Erstellen Sie ein Objekt für den SyslogLogger und übergeben Sie die Konfiguration als Parameter.

4. Rufen Sie die Log-Methode bei Bedarf auf und übergeben Sie die Log-Meldung und die Protokollierungsstufe.

5. Das Log-Objekt wird am Ende entsorgt.

Erste Schritte mit Prism-Protokollen

Einrichten von Prism in C# Projekten

Die Integration von Prism in ein C#-Projekt ist einfach. Die Verwendung von NuGet, dem .NET-Paketmanager von Microsoft, ist erforderlich, um Prism hinzuzufügen. Die Tools und Bibliotheken, die für die Integration von Prism Logs in Ihre Projekte erforderlich sind, werden von dieser Bibliothek bereitgestellt.

Implementierung von Prism in Dot .NET-Anwendungen

Prism ist mit einer Reihe von Dot .NET-Anwendungstypen kompatibel, darunter Windows Forms (WinForms) und Windows-Konsole. Obwohl jedes Framework anders implementiert ist, ist das Grundkonzept immer dasselbe: Es unterstützt uns bei der Protokollierung der Daten, die mit Ihrer Anwendung zusammenhängen.

Erstellen eines neuen Projekts in Visual Studio

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

Geben Sie den Projektnamen in den dafür vorgesehenen Textbereich ein, nachdem Sie den Speicherort der Datei ausgewählt haben. Wählen Sie dann, wie im Beispiel unten gezeigt, das erforderliche .NET-Framework aus, indem Sie auf die Schaltfläche Erstellen klicken.

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

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

Ein grundlegendes Beispiel für die Verwendung von Protokollen mit Prism.

Im folgenden Codebeispiel starten wir das Prism-Protokollobjekt und fügen dann verschiedene Protokollierungsebenen nacheinander in die Prism-Protokolle ein und speichern alle Protokolle und Kritikalität in einer Liste.

using Prism.Logging.Syslog;
class Program
{
    public class Demo
    {
        public string name { get; set; }
        public int age { get; set; }
        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 started.", Prism.Logging.Syslog.Level.Information);
        }
        static void PerformApplicationLogic()
        {
            // Example application logic
            Console.WriteLine("Performing application logic...");
            // Simulate error
            try
            {
                throw new Exception();// This will throw an exception
            }
            catch (Exception ex)
            {
                MessageLog($"Error occurred: {ex.Message}", Prism.Logging.Syslog.Level.Error);
            }
        }
        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;
class Program
{
    public class Demo
    {
        public string name { get; set; }
        public int age { get; set; }
        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 started.", Prism.Logging.Syslog.Level.Information);
        }
        static void PerformApplicationLogic()
        {
            // Example application logic
            Console.WriteLine("Performing application logic...");
            // Simulate error
            try
            {
                throw new Exception();// This will throw an exception
            }
            catch (Exception ex)
            {
                MessageLog($"Error occurred: {ex.Message}", Prism.Logging.Syslog.Level.Error);
            }
        }
        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
Friend Class Program
	Public Class Demo
		Public Property name() As String
		Public Property age() As Integer
		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 started.", 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() ' This will throw an exception
			Catch ex As Exception
				MessageLog($"Error occurred: {ex.Message}", Prism.Logging.Syslog.Level.Error)
			End Try
		End Sub
		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

Protokollberichte werden von Prism Logging erstellt. Wir verwenden ein Tool namens Kiwi Syslog Service Manager zur Überwachung der Prism-Protokolle.

Ausgabe der Prism Log-Datei

Prism Logs Vorgänge

Erweiterbare Protokollierung

Die Protokollierungsmöglichkeiten von Prism.Plugin.Prism werden durch die Protokollierung erweitert, die mehr Funktionalität und Flexibilität bietet. Es bietet eine Reihe von Konfigurationsoptionen zur Anpassung von Protokollierungsstufen, Protokollierungszielen und anderen Variablen an die Protokollierungsanforderungen Ihrer Anwendung.

Mehrere Log-Ziele

Mit Prism.Plugin.Logging können Sie Protokollmeldungen an verschiedene Stellen weiterleiten, z. B. an die Konsole, an Dateien, Datenbanken und andere Protokollierungsdienste. 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 die ILoggerFacade-Schnittstelle von Prism implementieren, um benutzerdefinierte Logger zu erstellen. So können Sie benutzerdefinierte Protokollierungsfunktionen auf der Grundlage der Anforderungen Ihrer Anwendung erstellen oder eine Schnittstelle zu Protokollierungs-Frameworks von Drittanbietern einrichten.

Protokoll mit Prism Logs erstellen

Prism-Protokolle können mit ein paar Zeilen Code leicht erstellt werden. Nachstehend finden Sie ein Beispiel für die Erstellung eines Protokolls.

static Options genOptions = new Options
{
        HostNameOrIp = "127.0.0.1",
        Port = 514,
        AppNameOrTag = "LoggingDemo"
};
static SyslogLogger logger = new SyslogLogger(genOptions);
logger.Log(Message, _level);

static Options genOptions = new Options
{
        HostNameOrIp = "127.0.0.1",
        Port = 514,
        AppNameOrTag = "LoggingDemo"
};
static SyslogLogger logger = new SyslogLogger(genOptions);
logger.Log(Message, _level);

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(Message, _level)

Integration von Prism Logging und IronPDF

Gemeinsame Verwendung von Prism und IronPDF

Kombinieren *Prisma mit IronPDF in einem C#-Projekt eröffnet einige interessante Möglichkeiten. IronPDF ist ein fantastisches Werkzeug für die Konvertierung dieser Inhalte in PDFs, auch wenn Prism ein hervorragendes Werkzeug für die Arbeit mit Protokollen ist. Dank dieser Konnektivität können Programmierer Anwendungen erstellen, die den Artikel in einem individuell gestalteten PDF-Dokument protokollieren.

Prism-Protokollierung mit IronPDF

Wenn Sie eine Windows-Konsolenanwendung erstellen, die Prism Logs verwendet, können die Benutzer innerhalb Ihres Programms mit den Protokollen arbeiten. Diese Steuerung sollte auf die Konsole passen, so dass genügend Platz für die Erstellung von Protokollen bleibt. Hinzufügen von Server-Protokollvorgängen und HTTP-Protokollen.

IronPDF installieren

• Öffnen Sie die Visual Studio projekt.

• Wählen Sie "Werkzeuge" > "NuGet Package Manager" > "Package Manager Console".

  • Geben Sie in der Paketmanager-Konsole den folgenden Befehl ein und drücken Sie die Eingabetaste:

Install-Package IronPdf

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

  • Suchen Sie das IronPDF-Paket in den Suchergebnissen, wählen Sie es aus und klicken Sie dann auf die Schaltfläche "Installieren". Der Download und die Installation werden von Visual Studio automatisch durchgeführt.

  

• NuGet wird das IronPDF-Paket und alle für Ihr Projekt erforderlichen Abhängigkeiten herunterladen und installieren.
• Sobald IronPDF installiert ist, können Sie es für Ihr 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 IronPDFs Funktionen, Kompatibilität und andere Download-Optionen zu erfahren.

DLL zur Installation verwenden

Alternativ können Sie IronPDF auch direkt in Ihr Projekt einbinden, indem Sie die DLL-Datei verwenden. Um die ZIP-Datei mit der DLL herunterzuladen, klicken Sie hier link. Nachdem Sie die DLL entpackt haben, fügen Sie sie in Ihr Projekt ein.

Umsetzung der Logik

• Einrichten des Renderers und des Loggers: Die Software richtet den IronPDF-Renderer und den Prism-Logger ein.
• Meldungen protokollieren: Nachrichten mit einer bestimmten Kategorie und Priorität können mit der Funktion MessageLog protokolliert werden()** Methode. In diesem Beispiel protokollieren wir die Start- und Stoppmeldungen der Anwendung sowie alle Ausnahmen, die während der Ausführung der Anwendung auftreten.
• Anwendungslogik: Ein Teil der Anwendungslogik wird durch die Funktion *PerformApplicationLogic simuliert()** Methode. Um die Fehlerprotokollierung zu veranschaulichen, wird in diesem Fall lediglich eine Meldung ausgegeben und eine Ausnahme ausgelöst.

• Erstellung eines PDF-Protokollberichts: Nach der Ausführung der Anwendungslogik erstellt die Software ein HTML-Dokument auf der Grundlage der aufgezeichneten Meldungen. Anschließend wird die IronPDF-Funktion RenderHtmlAsPdf() Funktion zur Umwandlung des HTML-Dokuments in eine Protokolldatei als PDF-Bericht. Die PDF-Datei wird dann auf der Festplatte gespeichert.

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

using IronPdf;
static void GeneratePdfLogReport(ChromePdfRenderer Renderer)
{
    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>{log.message}:</strong> {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(ChromePdfRenderer Renderer)
{
    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>{log.message}:</strong> {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
Shared Sub GeneratePdfLogReport(ByVal Renderer As ChromePdfRenderer)
	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>{log.message}:</strong> {log.Level}</li>"
		Next log
		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

Nachfolgend finden Sie den von IronPDF erstellten Bildprotokollbericht

Weitere Informationen über die IronPDF-Code-Referenzen finden Sie unter hier.

Schlussfolgerung

Prism.Plugin.Logging integration mit IronPDF ermöglicht Entwicklern die einfache Integration umfangreicher Protokollierungsfunktionen in Terminalanwendungen. Entwickler können die gesamte Programmpflege verbessern, die Debugging-Funktionen optimieren und die Protokollierungsvorgänge beschleunigen, indem sie die Funktionen beider Tools nutzen. Prism.Plugin.Logging ermöglicht es Konsolenanwendungen, eine vollständige Protokollierung zu erhalten, die mit der richtigen Implementierung und Einrichtung starke Überwachungs- und Fehlerbehebungsfunktionen garantiert.

IronPDF bietet eine unbefristete Lizenz zum Preis von 749 $ als Lite-Paket an, das eine permanente Lizenz, ein Jahr Software-Wartung und ein Upgrade der Bibliothek enthält. IronPDF bietet eine kostenlose Lizenz für Entwicklungszwecke an, die zeitlichen Beschränkungen und der Weiterverbreitung unterliegt. Zum Erwerb des kostenloser Test. Um mehr über die verschiedenen Produkte von Iron Software zu erfahren, besuchen Sie bitte die Website website link.