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

Les applications console, malgré leur absence d'interface 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 de manière efficace. Prism.Plugin.Logging, une extension du cadre de journalisation Prism, offre une solution de journalisation complète pour les applications .NET, comprenant la prise en charge de divers fournisseurs de journalisation.

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

Introduction à la journalisation Prism

Prism.Plugin.Logging étend Prism, un cadre populaire pour construire des applications XAML, en offrant des capacités de journalisation complètes. Avec la prise en charge de plusieurs fournisseurs de journalisation tels que NLog, Serilog et Microsoft.Extensions.Logging, Prism.Plugin.Logging offre une flexibilité et des options de personnalisation pour répondre aux exigences de diverses applications.

Avantages de l'utilisation de l'enregistrement Prism

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

Support de journalisation structurée : Les développeurs peuvent enregistrer 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 de l'utilisateur, doivent être enregistrées et ajoutées aux rapports de journal produits par IronPDF.

Comment utiliser Prism logging

1. Créer un nouveau projet C#

2. Installez le paquetage de journalisation Prism.

3. Créer un objet pour le SyslogLogger et passer la configuration en paramètre.

4. Appelez la méthode log à chaque fois que cela est nécessaire et transmettez le message de log et le niveau de log.

5. Élimine l'objet journal à la fin.

Premiers pas avec les journaux de Prism

Mise en place de Prism dans C# ; Projets

L'intégration de Prism dans un projet C# est facile. L'utilisation de NuGet, le gestionnaire de paquets .NET de Microsoft, est nécessaire pour ajouter Prism. Cette bibliothèque fournit les outils et les bibliothèques nécessaires à l'intégration des journaux Prism dans vos projets.

Mise en œuvre de Prism dans les applications Dot .NET

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

Création d'un nouveau projet dans Visual Studio

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

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

L'application choisie déterminera ensuite l'organisation du projet Visual Studio. Il suffit d'ouvrir le fichier program.cs pour commencer à ajouter du code à l'application et à la construire. Vous pouvez utiliser Windows, la console ou l'application web.

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

Exemple de base d'utilisation des logs avec Prism.

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

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

Fichier journal de sortie de Prism

Prism Logs Operations

Journalisation extensible

Les capacités de journalisation de Prism.Plugin.Prism sont étendues grâce à la journalisation, qui offre plus de fonctionnalités et de flexibilité. Il offre une série d'options de configuration permettant d'ajuster les niveaux de journalisation, les cibles de journalisation et d'autres variables afin de répondre aux besoins de journalisation de votre application.

Cibles multiples

Avec Prism.Plugin.Logging, vous pouvez acheminer les messages de journalisation vers divers emplacements, y compris la console, les fichiers, les bases de données et d'autres services de journalisation. Grâce à cette flexibilité, vous pouvez sélectionner les cibles de journalisation les mieux adaptées aux exigences et à l'environnement de votre application.

Enregistreurs personnalisés

Avec le plugin, vous pouvez implémenter l'interface ILoggerFacade de Prism pour construire des loggers personnalisés. Cela vous permet de construire des capacités de journalisation personnalisées en fonction des besoins de votre application ou de vous interfacer avec des structures de journalisation tierces.

Créer un journal avec Prism Logs

Les journaux Prism peuvent être facilement créés avec quelques lignes de code. Vous trouverez ci-dessous un exemple de création d'un journal.

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)

Intégration de Prism Logging et IronPDF

Utilisation conjointe de Prism et IronPDF

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 les journaux. Grâce à cette connectivité, les programmeurs peuvent créer des applications qui enregistrent l'article dans un document PDF personnalisé.

Logging Prism avec IronPDF

En créant une application console Windows qui utilise les Logs de Prism, les utilisateurs peuvent s'engager avec les Logs à l'intérieur de votre programme. Cette commande doit tenir sur la console et il doit rester suffisamment de place pour créer des registres. Ajouter les journaux des opérations du serveur et les journaux HTTP.

Installer IronPDF

• Ouvrez le projet Visual Studio.

• Choisissez "Outils" > "NuGet Package Manager" > "Console du gestionnaire de paquets".

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

Install-Package IronPdf

Install-Package IronPdf

• Une autre façon d'installer IronPDF est d'utiliser NuGet Package Manager for Solutions.

  • Recherchez le paquet IronPDF dans les résultats de la recherche, sélectionnez-le, puis cliquez sur le bouton "Installer". Visual Studio se chargera automatiquement du téléchargement et de l'installation.

  

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

Installation via le site Web de NuGet

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

Utiliser la DLL pour l'installation

Alternativement, vous pouvez intégrer IronPDF directement dans votre projet en utilisant son fichier DLL. Pour télécharger le fichier ZIP contenant la DLL, cliquez sur ce lien. Une fois qu'elle a été décompressée, incluez la DLL dans votre projet.

Mise en œuvre de la logique

• Configuration du moteur de rendu et du journaliseur : Le logiciel configure le moteur de rendu IronPDF et le journaliseur Prism.
• Messages de journalisation : Les messages avec une catégorie et une priorité désignées peuvent être consignés à l'aide de la méthode MessageLog(). Dans cet exemple, nous enregistrons les messages de démarrage et d'arrêt de l'application ainsi que toutes les exceptions qui surviennent 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, il se contente de produire un message et de soulever 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 fonctionnalité RenderHtmlAsPdf() de IronPDF pour transformer le document HTML en un fichier journal sous forme de rapport PDF. Le fichier PDF est ensuite enregistré sur le disque.

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

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

Vous trouverez ci-dessous le rapport du journal d'images généré par IronPDF

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

Conclusion

L'intégration de Prism.Plugin.Logging avec IronPDF permet aux développeurs d'incorporer facilement une capacité de journalisation étendue 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 la journalisation, garantissant de solides capacités de surveillance et de dépannage, avec une mise en œuvre et une configuration appropriées.

IronPDF offre une licence perpétuelle du pack Lite $749 qui comprend une licence permanente, un an de maintenance logicielle et une mise à niveau de la bibliothèque. IronPDF offre des licences gratuites à 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 divers produits d'Iron Software, veuillez visiter leur site web.