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

Enregistrement est un élément crucial du développement de logiciels, en particulier dans des langages comme le C#. Il aide les développeurs à suivre les événements qui se produisent pendant l'exécution d'un programme, ce qui facilite la compréhension de son comportement et le diagnostic des problèmes. Ce guide couvrira tous les aspects de la journalisation et de l'enregistrement en C#Caractéristiques d'IronPDF pour la manipulation avancée des PDFles outils de journalisation, depuis les concepts de base jusqu'aux configurations et outils de journalisation avancés. Il permet de comprendre et de contrôler la configuration de la journalisation dans vos applications.

Comprendre la journalisation dans C# ;

La journalisation en C# consiste essentiellement à enregistrer des informations sur le logiciel au cours de son exécution. Ces enregistrements, ou messages de journal, sont stockés dans des fichiers journaux ou sur d'autres supports et peuvent inclure des données telles que des messages d'erreur, des informations sur l'état du logiciel ou des messages de débogage. L'objectif de la journalisation est de fournir un moyen de capturer des informations sur le fonctionnement de l'application dans un format persistant. Ces informations sont précieuses pour déboguer les problèmes, contrôler les performances du logiciel et s'assurer que l'application se comporte comme prévu. Il s'agit du fichier de configuration, de l'API de journalisation, de la configuration de la journalisation, des journaux structurés et des exceptions de journalisation.

Écriture des messages du journal

Pour commencer la journalisation en C#, les développeurs doivent écrire des messages de journalisation dans leur application. Pour ce faire, on utilise un cadre ou une API de journalisation. En C#, un choix populaire est l'interface ILogger de Microsoft disponible dans l'espace de noms Microsoft.Extensions.Logging. Cette interface offre un moyen simple d'enregistrer des données à différents niveaux d'importance, appelés niveaux d'enregistrement. Ces niveaux, qui comprennent Information, Débogage et Erreur, permettent de classer et de filtrer les journaux en fonction de la gravité des messages enregistrés.

using Microsoft.Extensions.Logging;
public class Program
{
    static void Main(string [] args)
    {
        ILogger logger = LoggerFactory.Create(builder => 
        {
            builder.AddConsole();
        }).CreateLogger<Program>();
        logger.LogInformation("This is an information log message");
        logger.LogError("This is an error log message");
    }
}

using Microsoft.Extensions.Logging;
public class Program
{
    static void Main(string [] args)
    {
        ILogger logger = LoggerFactory.Create(builder => 
        {
            builder.AddConsole();
        }).CreateLogger<Program>();
        logger.LogInformation("This is an information log message");
        logger.LogError("This is an error log message");
    }
}

Imports Microsoft.Extensions.Logging
Public Class Program
	Shared Sub Main(ByVal args() As String)
		Dim logger As ILogger = LoggerFactory.Create(Sub(builder)
			builder.AddConsole()
		End Sub).CreateLogger<Program>()
		logger.LogInformation("This is an information log message")
		logger.LogError("This is an error log message")
	End Sub
End Class

Dans l'exemple ci-dessus, l'objet ILogger nommé logger est configuré pour envoyer des messages à la console. Cette configuration est simple mais fondamentale pour comprendre comment les messages sont générés et affichés.

Fichiers journaux et fournisseurs

Dans une application réelle, il est souvent nécessaire de stocker les messages du journal dans un fichier ou un autre système de stockage en vue d'un examen ultérieur. C'est là que les fournisseurs de services d'enregistrement entrent en jeu. Les fournisseurs sont des composants du cadre de journalisation qui gèrent la sortie des données de journalisation vers diverses destinations telles que des fichiers, des bases de données ou des services externes.

Par exemple, pour configurer un enregistreur afin qu'il écrive des messages dans un fichier, vous pouvez utiliser un fournisseur de fichiers comme FileLoggerProvider. Pour ce faire, il faut modifier le fichier de configuration de l'application(souvent appsettings.json dans les applications .NET) pour spécifier des détails tels que le chemin d'accès au fichier journal et le niveau minimum de journalisation.

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning"
    },
    "File": {
      "Path": "logs/myapp.log"
    }
  }
}

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning"
    },
    "File": {
      "Path": "logs/myapp.log"
    }
  }
}

"Logging":
  If True Then
	"LogLevel":
	If True Then
	  "Default": "Information", "Microsoft": "Warning"
	End If
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'   , "File":
'	{
'	  "Path": "logs/myapp.log"
'	}
  End If

La configuration spécifie que tous les enregistrements par défaut doivent être au niveau "Information", mais que les bibliothèques de Microsoft ne doivent enregistrer que les avertissements et les informations supérieures. Il dirige également la sortie de la journalisation vers un fichier journal nommé myapp.log dans un répertoire logs.

Techniques avancées de journalisation

Au-delà des messages de journalisation de base, C# prend en charge la journalisation structurée, qui permet d'inclure des données structurées dans vos journaux au lieu de se contenter de texte brut. La journalisation structurée facilite la recherche et l'analyse des données de journalisation, car chaque élément d'information contextuelle est stocké dans un champ distinct.

logger.LogDebug("Processing order {OrderId} at {Timestamp}", orderId, DateTime.UtcNow);

logger.LogDebug("Processing order {OrderId} at {Timestamp}", orderId, DateTime.UtcNow);

logger.LogDebug("Processing order {OrderId} at {Timestamp}", orderId, DateTime.UtcNow)

Dans cet exemple de journal structuré, OrderId et Timestamp sont des espaces réservés dans le modèle de message qui seront remplis avec les valeurs orderId et DateTime.UtcNow respectivement. Cette méthode est plus puissante que la journalisation traditionnelle, car elle permet d'interroger et de manipuler plus facilement les données de la journalisation sur la base de champs spécifiques dans chaque entrée de la journalisation.

Intégration avec des systèmes externes

La journalisation en C# peut être étendue pour s'intégrer à des systèmes externes tels que SQL Server ou Windows Event Log, améliorant ainsi la gestion et l'analyse des données de journalisation. En utilisant des fournisseurs de journalisation spécialisés, les messages de journalisation peuvent être dirigés vers ces systèmes, fournissant ainsi des capacités plus robustes pour la surveillance des erreurs et la réponse.

builder.AddEventLog(new EventLogSettings
{
    SourceName = "MyApplication"
});

builder.AddEventLog(new EventLogSettings
{
    SourceName = "MyApplication"
});

builder.AddEventLog(New EventLogSettings With {.SourceName = "MyApplication"})

Cet extrait de configuration dirige la sortie du journal vers le journal des événements de Windows sous le nom de source "MyApplication". Ceci est particulièrement utile pour les applications fonctionnant sur des serveurs Windows où le journal des événements est un outil centralisé pour la surveillance des logiciels et des messages système.

Intégration d'IronPDF avec C&num ;

Enregistrement

En savoir plus sur IronPDF pour la conversion de HTML en PDF est une bibliothèque PDF .NET qui permet aux développeurs de créer, de manipuler et de rendre des PDF. Il convertit le HTML en PDF, ce qui est une exigence courante pour générer des rapports, des factures et d'autres types de documents à partir de contenu web. IronPDF offre un ensemble complet de fonctionnalités qui permettent d'effectuer diverses tâches liées aux PDF, notamment l'édition de texte et d'images, la sécurisation des documents et même l'extraction de contenu.

La combinaison d'IronPDF et de la journalisation C# permet d'améliorer la gestion des erreurs et le débogage lors de l'utilisation de fichiers PDF. L'intégration de la journalisation vous permet de suivre le processus de génération de PDF et de capturer tous les problèmes ou exceptions qui surviennent. Cette intégration est particulièrement utile dans les scénarios où la génération de PDF est un élément essentiel de la fonctionnalité de l'application, comme la génération de rapports dynamiques basés sur les données de l'utilisateur.

Exemple de code

Pour utiliser IronPDF avec la journalisation C#, vous devez incorporer des appels à la journalisation dans vos opérations PDF. Voici un exemple d'intégration de ces deux technologies dans une application .NET. Cet exemple suppose que vous utilisez l'interface ILogger de Microsoft.Extensions.Logging.

using IronPdf;
using Microsoft.Extensions.Logging;
using System;
public class PdfGenerator
{
    private readonly ILogger _logger;
    public PdfGenerator(ILogger<PdfGenerator> logger)
    {
        _logger = logger;
    }
    public void CreatePdfFromHtml(string htmlContent, string outputPath)
    {
        try
        {
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf(htmlContent);
            pdf.SaveAs(outputPath);
            _logger.LogInformation("PDF created successfully at {OutputPath}", outputPath);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error creating PDF from HTML");
        }
    }
}
// Usage
public class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
        {
            builder.AddConsole(); // Works after adding the right package and using directive
        });
        ILogger<PdfGenerator> logger = loggerFactory.CreateLogger<PdfGenerator>(); // Correct type parameter
        PdfGenerator pdfGenerator = new PdfGenerator(logger);
        string htmlContent = "<h1>Hello, PDF!</h1><p>This is a simple PDF generated from HTML.</p>";
        string outputPath = "output.pdf";
        pdfGenerator.CreatePdfFromHtml(htmlContent, outputPath);
    }
}

using IronPdf;
using Microsoft.Extensions.Logging;
using System;
public class PdfGenerator
{
    private readonly ILogger _logger;
    public PdfGenerator(ILogger<PdfGenerator> logger)
    {
        _logger = logger;
    }
    public void CreatePdfFromHtml(string htmlContent, string outputPath)
    {
        try
        {
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf(htmlContent);
            pdf.SaveAs(outputPath);
            _logger.LogInformation("PDF created successfully at {OutputPath}", outputPath);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error creating PDF from HTML");
        }
    }
}
// Usage
public class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
        {
            builder.AddConsole(); // Works after adding the right package and using directive
        });
        ILogger<PdfGenerator> logger = loggerFactory.CreateLogger<PdfGenerator>(); // Correct type parameter
        PdfGenerator pdfGenerator = new PdfGenerator(logger);
        string htmlContent = "<h1>Hello, PDF!</h1><p>This is a simple PDF generated from HTML.</p>";
        string outputPath = "output.pdf";
        pdfGenerator.CreatePdfFromHtml(htmlContent, outputPath);
    }
}

Imports IronPdf
Imports Microsoft.Extensions.Logging
Imports System
Public Class PdfGenerator
	Private ReadOnly _logger As ILogger
	Public Sub New(ByVal logger As ILogger(Of PdfGenerator))
		_logger = logger
	End Sub
	Public Sub CreatePdfFromHtml(ByVal htmlContent As String, ByVal outputPath As String)
		Try
			Dim renderer = New ChromePdfRenderer()
			Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
			pdf.SaveAs(outputPath)
			_logger.LogInformation("PDF created successfully at {OutputPath}", outputPath)
		Catch ex As Exception
			_logger.LogError(ex, "Error creating PDF from HTML")
		End Try
	End Sub
End Class
' Usage
Public Class Program
	Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		Dim loggerFactory As ILoggerFactory = LoggerFactory.Create(Sub(builder)
			builder.AddConsole() ' Works after adding the right package and using directive
		End Sub)
		Dim logger As ILogger(Of PdfGenerator) = loggerFactory.CreateLogger(Of PdfGenerator)() ' Correct type parameter
		Dim pdfGenerator As New PdfGenerator(logger)
		Dim htmlContent As String = "<h1>Hello, PDF!</h1><p>This is a simple PDF generated from HTML.</p>"
		Dim outputPath As String = "output.pdf"
		pdfGenerator.CreatePdfFromHtml(htmlContent, outputPath)
	End Sub
End Class

Cette configuration facilite non seulement la génération de PDF à partir de HTML, mais garantit également que l'opération est bien documentée par des journaux, ce qui facilite la maintenance et le dépannage. L'intégration de la journalisation à IronPDF peut améliorer considérablement la fiabilité et la traçabilité des capacités de traitement des PDF de votre application.

Conclusion

La journalisation en C# est un moyen souple et puissant de capturer des informations détaillées sur le fonctionnement de votre application. En utilisant différents niveaux de journalisation, en configurant divers fournisseurs et en mettant en œuvre une journalisation structurée, les développeurs peuvent créer un système de journalisation complet qui améliore la maintenabilité et le débogage de leurs applications.

Essai gratuit d'IronPDF à partir de $749.