Microsoft Logging C# (Comment ça marche pour le développeur)

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 fait partie des 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 journaux. Dans cet article, nous allons en savoir plus sur la journalisation de MS.

Comment configurer l'enregistrement MS

1. Créer un nouveau Visual Studio projet.

2. Installez la bibliothèque Microsoft.Extensions.Logging à partir de NuGet.

3. Injecte 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 à l'aide de la commande 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. Naviguez vers Outils > NuGet Package Manager > Package Manager Console.

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

    Install-Package Microsoft.Extensions.Logging

4. Appuyez sur Enter pour exécuter la commande. Ceci téléchargera et installera le paquet 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 journalisation en fonction de leur importance et de 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 offerts par Microsoft.Extensions.Logging sont les suivants :

• Trace : Le niveau le plus complet, souvent utilisé pour des données incroyablement détaillées qui permettent de comprendre en profondeur le fonctionnement interne du programme.
• Debug : Informations de débogage utiles pendant les phases de développement et de débogage, mais souvent inutiles dans un environnement de production.
• Informations : 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 : Signale un problème éventuel ou tout ce qui pourrait nécessiter une attention particulière à 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 : Signale 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 les problèmes critiques qui doivent être traités immédiatement car ils peuvent entraîner des problèmes graves ou des pannes de 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 de la journalisation en C

Voici un exemple basique de comment 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 offre différents fournisseurs de journalisation, y compris la journalisation vers des fichiers, des bases de données, ou la connexion avec d'autres cadres 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 enchaînant les méthodes correspondantes dans la classe Create() fonction. Par exemple :

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

MSLogging sur IronPDF

Pour activer la journalisation dans IronPDF, vous pouvez utiliser le framework Microsoft.Extensions.Logging avec 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 du framework Microsoft.Extensions.Logging. Nous créons ensuite un logger à partir de la fabrique de la classe Program.

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

Après avoir effectué les opérations nécessaires avec IronPDF, vous pouvez fermer et disposer des ressources, puis vider les messages de log en disposant de la loggerFactory.

Note : Assurez-vous que vous avez les dépendances et les 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

3. Appuyez sur Enter 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

À partir de 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, visitez le site officiel.

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, dont un ensemble 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 consulter son site web officiel à l'adresse suivante https://ironsoftware.com/.