Les applications de console, malgré leur absence d'interface utilisateur graphique, nécessitent souvent des mécanismes de journalisation robustes pour suivre les erreurs, surveiller les performances de l'application et déboguer les problèmes efficacement. Prism.Plugin.Logging, une extension du cadre de journalisation Prism, offre une solution de journalisation complète pour les applications .NET, y compris le support pour divers fournisseurs de journalisation.

Dans cet article, nous explorons comment intégrer Prism Logging dans les applications de console en utilisant IronPDF, une bibliothèque .NET puissante pour travailler avec les documents PDF. En combinant ces outils, les développeurs peuvent mettre en œuvre des fonctionnalités de journalisation avancées dans leurs applications de console, améliorant les capacités de maintenance et de dépannage.

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

Setting up Prism in C# Projects

Intégrer Prism dans un projet C# est facile. Utiliser NuGet, le gestionnaire de packages .NET de Microsoft, est nécessaire pour ajouter Prism. Les outils et bibliothèques nécessaires pour incorporer Prism Logs dans vos projets sont fournis par cette bibliothèque.

Implémenter Prism dans les applications Dot .NET

Prism est compatible avec plusieurs types d'applications Dot .NET, y compris les Windows Forms (WinForms) et la console Windows. Bien que chaque cadre soit mis en œuvre différemment, le concept de base est toujours le même, nous aidant à journaliser les données relatives à votre application.

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

Un exemple basique d'utilisation des journaux Prism

Dans l'exemple de code ci-dessous, nous initialisons l'objet de journal Prism, puis ajoutons différents niveaux de journalisation un par un dans les journaux Prism, enregistrant tous les journaux et leur criticité dans une 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

Des rapports de journal sont générés à partir de Prism Logging. Nous utilisons un outil appelé Kiwi Syslog Service Manager pour surveiller les journaux Prism.

Fichier de sortie Prism Log

Opérations des journaux Prism

Journalisation extensible

Les capacités de Prism.Plugin.Logging sont étendues via la journalisation, qui offre plus de fonctionnalités et de flexibilité. Il offre une gamme d'options de configuration pour ajuster les niveaux de journal, les cibles de journal et d'autres variables pour répondre aux besoins de journalisation de votre application.

Multiples cibles de journal

Vous pouvez diriger les messages de journal vers divers emplacements, y compris la console, les fichiers, les bases de données et d'autres services de journalisation, avec Prism.Plugin.Logging. Grâce à cette flexibilité, vous pouvez sélectionner les meilleures cibles de journalisation pour les exigences et l'environnement de votre application.

Journalistes personnalisés

Avec le plugin, vous pouvez implémenter l'interface ILoggerFacade de Prism pour construire des journalistes personnalisés. Cela vous permet de construire des capacités de journalisation personnalisées basées sur les besoins de votre application ou d'interfacer avec des cadres de journalisation tiers.

Créer un journal avec les journaux Prism

Les journaux Prism peuvent être facilement créés avec quelques lignes de code. Ci-dessous se trouve l'exemple pour créer un journal.

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)

Intégration de Prism Logging et IronPDF

Utiliser Prism et IronPDF ensemble

Combiner Prism avec IronPDF dans un projet C# ouvre des possibilités passionnantes. IronPDF est un outil fantastique pour convertir ce contenu en PDF, même si Prism est un excellent outil pour travailler avec des journaux. Les programmeurs peuvent créer des applications qui journalisent l'élément dans un document PDF sur mesure grâce à cette connectivité.

Prism Logging avec IronPDF

En créant une application console Windows qui utilise Prism Logs, les utilisateurs peuvent interagir avec les journaux à l'intérieur de votre programme. Ce contrôle devrait s'adapter à la console en laissant suffisamment d'espace pour créer des journaux. Ajoutez des opérations de journalisation serveur et des journaux HTTP.

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 :

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

Installation via le site Web NuGet

Visitez la page IronPDF sur https://www.nuget.org/packages/IronPdf sur le site NuGet pour en savoir plus sur les fonctionnalités, la compatibilité et d'autres options de téléchargement d'IronPDF.

Utiliser DLL pour installer

Alternativement, vous pouvez intégrer IronPDF directement dans votre projet en utilisant son fichier DLL. Pour télécharger le fichier ZIP contenant le DLL, cliquez sur ce lien. Une fois décompressé, incluez le DLL dans 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

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

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 de Lite bundle qui comprend une licence permanente, un an de maintenance logicielle et une mise à jour 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.