Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. prism-journalisation
.NET AIDE

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

Curtis Chau
Curtis Chau
Mis à jour:

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

Configurer Prism dans les projets C#

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.

Prism Logging (Comment cela fonctionne pour les développeurs) : Figure 1 - Installez Prism en utilisant le gestionnaire de packages NuGet pour la solution en recherchant Prism.Plugin.Logging.Loggly dans la barre de recherche du gestionnaire de packages NuGet, puis sélectionnez le projet et cliquez sur le bouton Installer.

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éation d'un nouveau projet dans Visual Studio

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

Prism Logging (Comment cela fonctionne pour les développeurs) : Figure 2 - Ouvrez Visual Studio et sélectionnez Nouveau projet - Sélectionnez Console App

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.

Prism Logging (Comment cela fonctionne pour les développeurs) : Figure 3 - Ensuite, configurez votre projet en spécifiant le nom et l'emplacement désirés du projet. Sélectionnez le Framework .NET correspondant pour votre projet et cliquez 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
$vbLabelText   $csharpLabel

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

Prism Logging (Comment cela fonctionne pour les développeurs) : Figure 4 - Surveillez les rapports de journal Prism générés en utilisant l'outil Kiwi Syslog Service Manager.

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)
$vbLabelText   $csharpLabel

Intégration de Prism Logging et IronPDF

Utiliser Prism et IronPDF ensemble

Combining Prism with IronPDF in a C# project opens some exciting possibilities. 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 :
    Install-Package IronPdf
  • Une autre façon d'installer IronPDF est d'utiliser le gestionnaire de packages NuGet pour les solutions.
    • Parcourez le package IronPDF dans les résultats de recherche, sélectionnez-le, puis cliquez sur le bouton "Installer". ### 4.2 Installer avec la console de gestion de packages NuGet

Prism Logging (Comment cela fonctionne pour les développeurs) : Figure 5 - Installez IronPDF en utilisant le gestionnaire de packages NuGet pour la solution en recherchant IronPdf dans la barre de recherche du gestionnaire de packages NuGet, puis sélectionnez le projet et cliquez sur le bouton Installer.

  • 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.
  • Messages de journalisation : Les messages avec une catégorie et une priorité désignées peuvent être journalisés en utilisant 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 en PDF : Après 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
$vbLabelText   $csharpLabel

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

Prism Logging (Comment cela fonctionne pour les développeurs) : Figure 6 - Sortie PDF générée en utilisant IronPDF et les données du rapport de journal Prism.

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

Conclusion

Prism.Plugin.Logging integration with L'intégration de 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 offre une licence perpétuelle d'un Lite bundle qui inclut une licence permanente, une année 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.

Questions Fréquemment Posées

Comment puis-je intégrer la journalisation dans une application console .NET ?

Vous pouvez intégrer la journalisation dans une application console .NET en utilisant Prism.Plugin.Logging, qui prend en charge divers fournisseurs de journalisation et offre un cadre de journalisation structuré. Pour le configurer, installez le package de journalisation Prism, créez les objets de journalisation nécessaires et configurez vos cibles et niveaux de journalisation.

Quels sont les avantages de combiner Prism Logging avec IronPDF ?

Combiner Prism Logging avec IronPDF vous permet de générer des rapports de journaux PDF, améliorant la maintenance et le dépannage des applications. IronPDF peut convertir le contenu des journaux HTML en documents PDF, fournissant un format portable pour la révision et le partage des journaux.

Comment puis-je convertir des données de journal en document PDF sous .NET ?

Pour convertir des données de journal en document PDF sous .NET, utilisez IronPDF pour rendre vos données de journal en HTML puis convertissez-le en PDF en utilisant des méthodes telles que RenderHtmlAsPdf. Cela vous permet de créer des rapports de journal détaillés et portables.

Quels fournisseurs de journalisation sont compatibles avec Prism.Plugin.Logging ?

Prism.Plugin.Logging est compatible avec de nombreux fournisseurs de journalisation, y compris NLog, Serilog et Microsoft.Extensions.Logging. Cette flexibilité permet aux développeurs de choisir le fournisseur de journalisation qui correspond le mieux aux besoins de leur projet.

Comment configurer un projet de journalisation Prism dans Visual Studio ?

Pour configurer un projet de journalisation Prism dans Visual Studio, créez un nouveau projet C#, installez le package de journalisation Prism en utilisant le gestionnaire de packages NuGet, et initialisez le cadre de journalisation en créant un objet SyslogLogger et en configurant les niveaux et cibles de journalisation.

Prism.Plugin.Logging peut-il être utilisé pour des configurations de journalisation personnalisées ?

Oui, Prism.Plugin.Logging prend en charge les configurations de journalisation personnalisées. Vous pouvez ajuster les niveaux de journal, définir des enregistreurs personnalisés et aiguiller les messages de journal vers diverses destinations, permettant une configuration de journalisation adaptée aux exigences spécifiques de l'application.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit