Prism Logging (Funktionsweise für Entwickler)

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

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.

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

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)

Integration von Prism Logging und IronPDF

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:

  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.

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

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

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 für Lite bundle an, die eine Dauerlizenz, ein Jahr Softwarewartung und ein Upgrade der Bibliothek beinhaltet. 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.