Test dans un environnement réel
Test en production sans filigrane.
Fonctionne partout où vous en avez besoin.
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.Loggingprism Logging, une extension du framework Prism Logging, offre une solution complète de journalisation pour les applications .NET, y compris la prise en charge de divers fournisseurs de journalisation.
Dans cet article, nous explorons comment intégrer Prism Logging dans les applications de console en utilisant IronPDFune puissante bibliothèque .NET 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.
Prism.Plugin.Logging étend Prism, un cadre populaire pour la construction d'applications XAML, en fournissant 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.
Flexible Logging Configuration: Prism.Plugin.Logging permet aux développeurs de configurer différents fournisseurs de logging de manière transparente, y compris des options populaires comme NLog, Serilog, et Microsoft.Extensions.Logging.
Structured Logging Support: 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.
Créer un nouveau projet C#
Installez le paquetage de journalisation Prism.
Créer un objet pour le SyslogLogger et passer la configuration en paramètre.
Appelez la méthode log à chaque fois que cela est nécessaire et transmettez le message de log et le niveau de log.
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.
Prism est compatible avec un certain nombre de types d'applications .NET, notamment 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 : il nous aide à enregistrer les données relatives à votre application.
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é.
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.
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.
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.
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.
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)
Combinaison 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é.
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.
Choisissez "Outils" > "NuGet Package Manager" > "Console du gestionnaire de paquets".
Install-Package IronPdf
Une autre façon d'installer IronPDF est d'utiliser NuGet Package Manager for Solutions.
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.
Vous pouvez également incorporer IronPDF directement dans votre projet en utilisant son fichier DLL. Pour télécharger le fichier ZIP contenant la DLL, cliquez sur le lien suivant lien. Une fois qu'elle a été décompressée, incluez la DLL dans votre projet.
Création d'un rapport de journal PDF: Suite à l'exécution de la logique d'application, le logiciel crée un document HTML basé sur les messages enregistrés. Il utilise ensuite la fonction RenderHtmlAsPdf d'IronPDF() Fonctionnalité permettant de transformer le document HTML en un fichier journal sous la forme d'un 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 du code IronPDF, consultez le site suivant ici.
Prism.Plugin.Logging l'intégration avec IronPDF permet aux développeurs d'incorporer facilement des capacités de journalisation étendues dans les applications de terminal. Les développeurs peuvent améliorer la maintenance globale des programmes, 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 propose une licence perpétuelle de $749 Lite bundle qui comprend une licence permanente, un an de maintenance du logiciel et une mise à jour 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 le essai gratuit. Pour en savoir plus sur les différents produits d'Iron Software, veuillez consulter leur site web site web lien.
9 produits de l'API .NET pour vos documents de bureau