Microsoft Logging C# (Comment cela fonctionne pour les développeurs)

Introduction

La journalisation est une technique essentielle en C# qui permet de capturer des informations, des avertissements, des erreurs et d'autres données pertinentes pendant l'exécution d'une application. Il aide les développeurs à surveiller le comportement de leurs programmes, à résoudre les problèmes et à comprendre le fonctionnement de l'application dans différents contextes. C# propose des cadres et des paquets de journalisation pour faciliter les tâches de journalisation. Microsoft.Extensions.Logging est parmi les frameworks de journalisation les plus utilisés dans les applications .NET Core. Le package NuGet Microsoft.Extensions.Logging pour .NET Core nous donne accès à plusieurs méthodes d'extension pour nous aider à écrire différents niveaux de log. Dans cet article, nous allons en savoir plus sur la journalisation de MS.

Comment configurer l'enregistrement MS

1. Créez un nouveau projet Visual Studio.

2. Installez la bibliothèque Microsoft.Extensions.Logging depuis la page du package Microsoft.Extensions.Logging sur NuGet.

3. Injectez l'interface Logger dans la console.

4. Configurer la sortie de la journalisation.

5. Rédiger des journaux à différents niveaux.

6. Exécutez le code.

Étape 1 : Créer un nouveau projet Visual Studio

Pour commencer, créez un nouveau projet dans Visual Studio.

Étape 2 : Installer la bibliothèque Microsoft.Extensions.Logging

Installez la bibliothèque Microsoft.Extensions.Logging en utilisant la page du package Microsoft.Extensions.Logging sur NuGet. Cette bibliothèque fournit les classes et méthodes nécessaires à la journalisation dans les applications .NET Core.

Étape 3 : Injecter l'interface Logger dans la console

Pour utiliser la fonctionnalité de journalisation, vous devez injecter une instance de l'interface Logger dans votre application console. Cela peut être fait en utilisant un cadre d'injection de dépendances ou en créant manuellement une instance de la classe Logger.

using Microsoft.Extensions.Logging;

// Inject the logger into the console
ILogger logger = LoggerFactory.Create(builder =>
{
    builder.AddConsole();
}).CreateLogger<Program>();

using Microsoft.Extensions.Logging;

// Inject the logger into the console
ILogger logger = LoggerFactory.Create(builder =>
{
    builder.AddConsole();
}).CreateLogger<Program>();

Imports Microsoft.Extensions.Logging

' Inject the logger into the console
Private logger As ILogger = LoggerFactory.Create(Sub(builder)
	builder.AddConsole()
End Sub).CreateLogger<Program>()

Étape 4 : Configurer la sortie de la journalisation

Configurez la manière dont les journaux doivent être édités. Pour ce faire, il suffit d'ajouter un ou plusieurs fournisseurs de journalisation au constructeur de journaux. Le fournisseur le plus courant est le logger de console, qui affiche les journaux dans la console.

builder.AddConsole(options =>
{
    options.TimestampFormat = "[HH:mm:ss] ";
});

builder.AddConsole(options =>
{
    options.TimestampFormat = "[HH:mm:ss] ";
});

builder.AddConsole(Sub(options)
	options.TimestampFormat = "[HH:mm:ss] "
End Sub)

Étape 5 : Écrire des journaux à différents niveaux

Vous pouvez désormais écrire des journaux à différents niveaux à l'aide de l'objet logger. Les méthodes de journalisation disponibles sont LogDebug(), LogInformation(), LogWarning(), LogError() et LogCritical().

logger.LogDebug("This is a debug message");
logger.LogInformation("This is an information message");
logger.LogWarning("This is a warning message");
logger.LogError("This is an error message");
logger.LogCritical("This is a critical message");

logger.LogDebug("This is a debug message");
logger.LogInformation("This is an information message");
logger.LogWarning("This is a warning message");
logger.LogError("This is an error message");
logger.LogCritical("This is a critical message");

logger.LogDebug("This is a debug message")
logger.LogInformation("This is an information message")
logger.LogWarning("This is a warning message")
logger.LogError("This is an error message")
logger.LogCritical("This is a critical message")

Étape 6 : Exécuter le code

Enfin, exécutez votre code et observez les journaux produits conformément aux paramètres configurés.

C'est tout ! Vous avez réussi à configurer et à utiliser la journalisation MS dans votre application C#.

Installation de MS Logging

Pour installer MS Logging, suivez les étapes suivantes :

1. Lancez Visual Studio.

2. Accédez à Outils > Gestionnaire de package NuGet > Console du gestionnaire de package.

3. Dans la console du gestionnaire de paquets, exécutez la commande suivante :

    Install-Package Microsoft.Extensions.Logging

4. Appuyez sur Entrée pour exécuter la commande. Cela téléchargera et installera le package Microsoft.Extensions.Logging dans votre projet.

Niveaux d'enregistrement

Plusieurs niveaux de journalisation sont disponibles dans le framework Microsoft.Extensions.Logging en C#, permettant aux développeurs de classer et de hiérarchiser les messages de journal selon leur importance et leur gravité. Ces niveaux sont fréquemment utilisés pour distinguer les différents types de messages et aider à réguler la verbosité des journaux.

Les niveaux de journalisation par défaut proposés par Microsoft.Extensions.Logging sont les suivants :

• Trace : Le niveau le plus approfondi, souvent utilisé pour des données extrêmement détaillées qui offrent une compréhension approfondie du fonctionnement interne du programme.
• Déboguer : Informations de débogage utiles pendant les phases de développement et de débogage, mais qui ne sont souvent pas nécessaires dans un environnement de production.
• Information : Offre des détails sur le fonctionnement normal de l'application. En général, le fonctionnement régulier du programme est contrôlé à l'aide de ces journaux.
• Avertissement : Indique un problème potentiel ou tout ce qui pourrait nécessiter une attention à l'avenir. Il est utilisé pour les situations anormales ou inattendues qui pourraient entraîner des problèmes, mais qui ne provoquent pas nécessairement un plantage du programme.
• Erreur : Indique un problème grave ou une erreur qui doit être corrigée immédiatement. Généralement utilisé pour enregistrer les problèmes qui affectent le fonctionnement de l'application.

• Critique : L'état le plus grave, utilisé pour enregistrer des problèmes critiques qui doivent être traités immédiatement car ils pourraient causer des problèmes sérieux ou des plantages du programme.

  Chaque niveau de journalisation a une fonction spécifique et permet aux développeurs de gérer la quantité de données produites par le cadre de journalisation. Les développeurs peuvent choisir le niveau approprié pour l'enregistrement des messages en fonction de la gravité et de l'importance des données enregistrées.

Configuration du journalisation C

Voici un exemple de base sur la façon de configurer la journalisation en utilisant Microsoft.Extensions.Logging :

using Microsoft.Extensions.Logging;
using System;

class Program
{
    // Create a LoggerFactory instance
    private static readonly ILoggerFactory LoggerFactory = LoggerFactory.Create(builder =>
    {
        // Add console logger
        builder.AddConsole();
        // You can add other logging providers here (e.g., AddDebug, AddFile, etc.)
    });

    // Create a logger
    private static readonly ILogger Logger = LoggerFactory.CreateLogger<Program>();

    static void Main(string [] args)
    {
        // Example log messages
        Logger.LogInformation("Information log");
        Logger.LogWarning("Warning log");
        Logger.LogError("Error log");

        try
        {
            // Simulate an exception
            throw new Exception("Exception occurred");
        }
        catch (Exception ex)
        {
            // Log exception details
            Logger.LogError(ex, "Exception log");
        }

        Console.ReadKey();
    }
}

using Microsoft.Extensions.Logging;
using System;

class Program
{
    // Create a LoggerFactory instance
    private static readonly ILoggerFactory LoggerFactory = LoggerFactory.Create(builder =>
    {
        // Add console logger
        builder.AddConsole();
        // You can add other logging providers here (e.g., AddDebug, AddFile, etc.)
    });

    // Create a logger
    private static readonly ILogger Logger = LoggerFactory.CreateLogger<Program>();

    static void Main(string [] args)
    {
        // Example log messages
        Logger.LogInformation("Information log");
        Logger.LogWarning("Warning log");
        Logger.LogError("Error log");

        try
        {
            // Simulate an exception
            throw new Exception("Exception occurred");
        }
        catch (Exception ex)
        {
            // Log exception details
            Logger.LogError(ex, "Exception log");
        }

        Console.ReadKey();
    }
}

Imports Microsoft.Extensions.Logging
Imports System

Friend Class Program
	' Create a LoggerFactory instance
	Private Shared ReadOnly LoggerFactory As ILoggerFactory = LoggerFactory.Create(Sub(builder)
		' Add console logger
		builder.AddConsole()
		' You can add other logging providers here (e.g., AddDebug, AddFile, etc.)
	End Sub)

	' Create a logger
	Private Shared ReadOnly Logger As ILogger = LoggerFactory.CreateLogger(Of Program)()

	Shared Sub Main(ByVal args() As String)
		' Example log messages
		Logger.LogInformation("Information log")
		Logger.LogWarning("Warning log")
		Logger.LogError("Error log")

		Try
			' Simulate an exception
			Throw New Exception("Exception occurred")
		Catch ex As Exception
			' Log exception details
			Logger.LogError(ex, "Exception log")
		End Try

		Console.ReadKey()
	End Sub
End Class

Dans cet exemple, un enregistreur de console est ajouté à la configuration de journalisation, qui écrit les journaux sur la console. Cependant, Microsoft.Extensions.Logging propose divers fournisseurs de journalisation, y compris la journalisation vers des fichiers, des bases de données, ou la connexion avec d'autres frameworks de journalisation. En outre, il est possible de créer des fournisseurs de journalisation personnalisés qui peuvent formater les journaux en fonction d'exigences spécifiques.

Intégration de fournisseurs supplémentaires pour l'enregistrement

Vous pouvez ajouter des sources de journalisation supplémentaires en chaînant les méthodes concernées dans la fonction Create(). Par exemple :

• Pour ajouter un fournisseur de journalisation de la sortie du débogueur, utilisez builder.AddDebug().
• Pour ajouter un fournisseur de journalisation de fichiers, utilisez builder.AddFile("log.txt").

MSLogging sur IronPDF

IronPDF excelle dans la conversion HTML en PDF, garantissant une préservation précise des mises en page et des styles d'origine. C'est parfait pour créer des PDF à partir de contenus basés sur le web, tels que des rapports, des factures et de la documentation. Avec la prise en charge des fichiers HTML, des URL et des chaînes HTML brutes, IronPDF produit facilement des documents PDF de haute qualité.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Pour activer la journalisation dans IronPDF, vous pouvez utiliser le framework Microsoft.Extensions.Logging ainsi que les capacités de journalisation intégrées d'IronPDF. Voici un exemple de la façon de configurer la journalisation dans IronPDF :

using Microsoft.Extensions.Logging;
using IronPdf;

class Program
{
    static void Main(string [] args)
    {
        ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
        {
            builder
                .AddConsole()
                .AddDebug();
        });

        ILogger<Program> logger = loggerFactory.CreateLogger<Program>();

        // Enable logging in IronPDF
        Logger.Log = new LoggerImplementation(logger);

        // Use IronPDF and perform operations
        // ...

        // Example of logging an error in IronPDF
        Logger.Log.Error("An error occurred while processing the PDF");

        // Example of logging a warning in IronPDF
        Logger.Log.Warning("This is a warning message");

        // Example of logging an information message in IronPDF
        Logger.Log.Information("This is an information message");

        // ...

        // Close and dispose resources
        // ...

        // Flush the log messages
        loggerFactory.Dispose();
    }
}

using Microsoft.Extensions.Logging;
using IronPdf;

class Program
{
    static void Main(string [] args)
    {
        ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
        {
            builder
                .AddConsole()
                .AddDebug();
        });

        ILogger<Program> logger = loggerFactory.CreateLogger<Program>();

        // Enable logging in IronPDF
        Logger.Log = new LoggerImplementation(logger);

        // Use IronPDF and perform operations
        // ...

        // Example of logging an error in IronPDF
        Logger.Log.Error("An error occurred while processing the PDF");

        // Example of logging a warning in IronPDF
        Logger.Log.Warning("This is a warning message");

        // Example of logging an information message in IronPDF
        Logger.Log.Information("This is an information message");

        // ...

        // Close and dispose resources
        // ...

        // Flush the log messages
        loggerFactory.Dispose();
    }
}

Imports Microsoft.Extensions.Logging
Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim loggerFactory As ILoggerFactory = LoggerFactory.Create(Sub(builder)
			builder.AddConsole().AddDebug()
		End Sub)

		Dim logger As ILogger(Of Program) = loggerFactory.CreateLogger(Of Program)()

		' Enable logging in IronPDF
		Logger.Log = New LoggerImplementation(logger)

		' Use IronPDF and perform operations
		' ...

		' Example of logging an error in IronPDF
		Logger.Log.Error("An error occurred while processing the PDF")

		' Example of logging a warning in IronPDF
		Logger.Log.Warning("This is a warning message")

		' Example of logging an information message in IronPDF
		Logger.Log.Information("This is an information message")

		' ...

		' Close and dispose resources
		' ...

		' Flush the log messages
		loggerFactory.Dispose()
	End Sub
End Class

Dans cet exemple, nous créons une instance de LoggerFactory à partir du framework Microsoft.Extensions.Logging. Nous créons ensuite un logger à partir de la fabrique pour la classe Program.

Pour activer la journalisation dans IronPDF, nous définissons la propriété statique Logger.Log sur une instance de LoggerImplementation qui prend le journal depuis loggerFactory. Avec cette configuration, vous pouvez utiliser les méthodes Logger.Log pour enregistrer des messages dans IronPDF.

Après avoir effectué les opérations nécessaires avec IronPDF, vous pouvez fermer et libérer les ressources, puis vider les messages de journal en supprimant le loggerFactory.

Remarque : Assurez-vous d'avoir les dépendances et paquets nécessaires installés pour Microsoft.Extensions.Logging et IronPDF.

Installer IronPDF

Pour installer la bibliothèque IronPDF, procédez comme suit :

1. Ouvrez la console du gestionnaire de paquets dans Visual Studio.

2. Entrez la commande suivante pour installer la bibliothèque IronPDF à l'aide de NuGet :

Install-Package IronPdf

Vous pouvez également utiliser le CLI .NET en exécutant la commande suivante dans le terminal :

dotnet add package IronPdf

dotnet add package IronPdf

3. Appuyez sur Entrée pour exécuter la commande. Ceci téléchargera et installera le paquetage IronPDF dans votre projet.

   Il est également possible d'installer la bibliothèque IronPDF à l'aide de l'interface graphique du gestionnaire de paquets NuGet. Il suffit de rechercher le paquet "IronPDF" dans l'onglet Parcourir, de sélectionner le paquet souhaité dans la liste et d'installer la dernière version d'IronPDF.

   Une fois l'installation terminée, vous pouvez commencer à utiliser la bibliothèque IronPDF dans votre projet.

Enregistrement de MS à l'aide d'IronPDF

Depuis janvier 2022, IronPDF n'interagit pas directement avec Microsoft.Extensions.Logging et n'est pas pris en charge nativement. IronPDF est principalement utilisé comme outil de création et de modification de PDF dans des programmes C#.

Cependant, vous pouvez toujours incorporer la journalisation en utilisant Microsoft.Extensions. En intégrant la journalisation dans votre programme C# parallèlement à IronPDF, vous pouvez gérer et enregistrer les événements liés à la production de PDF, au flux de travail de l'application ou aux problèmes qui surviennent lors de l'utilisation d'IronPDF.

Voici un exemple d'utilisation de Microsoft.Extensions pour intégrer la journalisation à IronPDF :

using Microsoft.Extensions.Logging;
using IronPdf;
using System;

class Program
{
    private static readonly ILoggerFactory LoggerFactory = LoggerFactory.Create(builder =>
    {
        builder.AddConsole(); // Add other logging providers as needed
    });

    private static readonly ILogger Logger = LoggerFactory.CreateLogger<Program>();

    static void Main(string [] args)
    {
        try
        {
            // Your IronPDF code for PDF generation or manipulation
            var Renderer = new IronPdf.HtmlToPdf();
            var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello World!</h1>");
            PDF.SaveAs("Output.pdf");
            Logger.LogInformation("PDF created successfully.");
        }
        catch (Exception ex)
        {
            Logger.LogError(ex, "An error occurred while generating the PDF.");
        }

        Console.ReadKey();
    }
}

using Microsoft.Extensions.Logging;
using IronPdf;
using System;

class Program
{
    private static readonly ILoggerFactory LoggerFactory = LoggerFactory.Create(builder =>
    {
        builder.AddConsole(); // Add other logging providers as needed
    });

    private static readonly ILogger Logger = LoggerFactory.CreateLogger<Program>();

    static void Main(string [] args)
    {
        try
        {
            // Your IronPDF code for PDF generation or manipulation
            var Renderer = new IronPdf.HtmlToPdf();
            var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello World!</h1>");
            PDF.SaveAs("Output.pdf");
            Logger.LogInformation("PDF created successfully.");
        }
        catch (Exception ex)
        {
            Logger.LogError(ex, "An error occurred while generating the PDF.");
        }

        Console.ReadKey();
    }
}

Imports Microsoft.Extensions.Logging
Imports IronPdf
Imports System

Friend Class Program
	Private Shared ReadOnly LoggerFactory As ILoggerFactory = LoggerFactory.Create(Sub(builder)
		builder.AddConsole() ' Add other logging providers as needed
	End Sub)

	Private Shared ReadOnly Logger As ILogger = LoggerFactory.CreateLogger(Of Program)()

	Shared Sub Main(ByVal args() As String)
		Try
			' Your IronPDF code for PDF generation or manipulation
			Dim Renderer = New IronPdf.HtmlToPdf()
			Dim PDF = Renderer.RenderHtmlAsPdf("<h1>Hello World!</h1>")
			PDF.SaveAs("Output.pdf")
			Logger.LogInformation("PDF created successfully.")
		Catch ex As Exception
			Logger.LogError(ex, "An error occurred while generating the PDF.")
		End Try

		Console.ReadKey()
	End Sub
End Class

Cet exemple démontre une manière simple de mettre en place Microsoft.Extensions.Logging au sein d'une application C# qui utilise IronPDF. Des messages de journalisation sont générés pour documenter la création réussie des PDF et pour enregistrer les éventuelles exceptions.

Veillez à personnaliser les niveaux de journalisation, la gestion des erreurs et les messages en fonction des besoins spécifiques de votre application et des scénarios dans lesquels IronPDF est utilisé pour la création ou la modification de PDF. Une différenciation adéquate des différents types de messages de journalisation à l'aide des niveaux de journalisation peut s'avérer utile pour un débogage et une surveillance efficaces.

Pour en savoir plus sur IronPDF, veuillez visiter la page d'accueil d'IronPDF.

Conclusion

En conclusion, l'intégration de Microsoft.Extensions.Logging permet aux développeurs C# de gérer efficacement les tâches de journalisation. IronPDF offre des fonctionnalités complètes de journalisation, permettant l'enregistrement, l'analyse et la création de rapports sur les événements, les défaillances et les données vitales de l'application. Cela améliore la fiabilité, la maintenance et le débogage des applications.

IronPDF propose différents produits logiciels, y compris un pack Lite au prix de $749. Cette offre comprend une licence permanente, des options de mise à niveau, un an de maintenance du logiciel et une garantie de remboursement de trente jours. Pendant la période d'essai en filigrane, vous pouvez explorer les fonctionnalités d'IronPDF. Pour en savoir plus sur les produits logiciels proposés par Iron Software, veuillez visiter le site officiel d'Iron Software.