Prism Logging (Comment ça fonctionne pour les développeurs)

Introduction à Prism Logging

Prism.Plugin.Logging étend Prism, un cadre populaire pour créer des applications XAML, en fournissant des capacités de journalisation complètes. Avec le support de plusieurs fournisseurs de journalisation tels que NLog, Serilog et Microsoft.Extensions.Logging, Prism.Plugin.Logging offre des options de flexibilité et de personnalisation pour répondre aux exigences variées des applications.

Avantages de l'utilisation de la journalisation Prism

Configuration de journalisation flexible : Prism.Plugin.Logging permet aux développeurs de configurer divers fournisseurs de journalisation de manière transparente, y compris des options populaires comme NLog, Serilog et Microsoft.Extensions.Logging.

Support de la journalisation structurée : Les développeurs peuvent journaliser des données structurées avec leurs messages en utilisant Prism.Plugin.Logging. Cette fonction est particulièrement utile dans les scénarios impliquant des applications de console où des données contextuelles complètes, y compris les horodatages, les codes d'erreur ou les activités des utilisateurs, doivent être enregistrées et ajoutées aux rapports de journal produits par IronPDF.

Comment utiliser la journalisation Prism

1. Créez un nouveau projet C#
2. Installez le package de journalisation Prism.
3. Créez un objet pour le SyslogLogger et passez la configuration en paramètre.
4. Appelez la méthode de journalisation quand nécessaire et passez le message de journalisation et le niveau de journalisation.
5. Disposez de l'objet journal à la fin.

Commencer avec Prism Logs

Créer un nouveau projet dans Visual Studio

Choisissez le menu Fichier dans l'application Visual Studio. Cliquez sur "Nouveau projet", puis choisissez "Application de console".

Saisissez le nom du projet dans la zone de texte désignée après avoir sélectionné l'emplacement du fichier. Puis, comme montré dans l'exemple ci-dessous, sélectionnez le .NET Framework nécessaire en cliquant sur le bouton Créer.

L'application choisie déterminera ensuite comment le projet Visual Studio est organisé. Ouvrez simplement le fichier program.cs pour commencer à ajouter du code à l'application et à la construire. Vous pouvez utiliser Windows, la console ou l'application web.

Après cela, la bibliothèque peut être ajoutée et le code testé.

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)

Intégration de Prism Logging et IronPDF

Installer IronPDF

• Ouvrez le projet Visual Studio.

• Choisissez "Outils" > "Gestionnaire de packages NuGet" > "Console du gestionnaire de packages".

  • Dans la console du gestionnaire de packages, tapez la commande suivante et appuyez sur Entrée :

  Install-Package IronPdf

• Une autre façon d'installer IronPDF est d'utiliser NuGet Package Manager for Solutions.
• Parcourez le package IronPDF dans les résultats de recherche, sélectionnez-le, puis cliquez sur le bouton "Installer". Visual Studio gérera le téléchargement et l'installation automatiquement.

• NuGet téléchargera et installera le package IronPDF et toutes les dépendances nécessaires pour votre projet.
• Une fois IronPDF installé, vous pouvez l'utiliser pour votre projet.

Implémentation de la logique

• Configuration du renderer et du logger : Le logiciel configure le renderer IronPDF et le logger Prism.
• Journalisation des messages : Les messages ayant une catégorie et une priorité désignées peuvent être enregistrés à l'aide de la méthode MessageLog() . Dans cet exemple, nous journalisons les messages de démarrage et d'arrêt de l'application ainsi que toute exception qui survient pendant l'exécution de l'application.
• Application de la logique : Une partie de la logique de l'application est simulée par la méthode PerformApplicationLogic(). Pour illustrer la journalisation des erreurs, elle produit simplement un message et génère une exception dans ce cas.
• Créer un rapport de journal PDF : À la suite de l'exécution de la logique de l'application, le logiciel crée un document HTML basé sur les messages enregistrés. Il utilise ensuite la fonction RenderHtmlAsPdf() d'IronPDF pour transformer le document HTML en fichier de journal sous forme de rapport PDF. Le fichier PDF est ensuite enregistré sur le disque.

Extension du code précédemment défini pour intégrer le code IronPDF :

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

Ci-dessous se trouve le journal d'image généré à partir d'IronPDF

Pour en savoir plus sur les références de code IronPDF, consultez ici.

Conclusion

L'intégration de Prism.Plugin.Logging avec IronPDF permet aux développeurs d'intégrer facilement des capacités de journalisation étendues dans les applications terminales. Les développeurs peuvent améliorer la maintenance globale du programme, optimiser les capacités de débogage et accélérer les opérations de journalisation en utilisant les fonctionnalités des deux outils. Prism.Plugin.Logging permet aux applications de console d'obtenir une couverture complète de journalisation, garantissant des capacités de surveillance et de dépannage solides, avec la bonne implémentation et configuration.

IronPDF propose une licence perpétuelle Lite bundle qui comprend une licence permanente, un an de maintenance logicielle et une mise à niveau de la bibliothèque. IronPDF offre une licence gratuite à des fins de développement, sous réserve de restrictions de temps et de redistribution. Pour acquérir la version d'essai gratuite. Pour en savoir plus sur les différents produits Iron Software, veuillez consulter leur site web.