Journalisation dans les applications C# : meilleures pratiques pour les débutants

Introduction : Pourquoi la journalisation est-elle importante ?

Imaginez que votre application C# fonctionne en production. Soudain, des utilisateurs signalent une erreur, mais vous ne pouvez pas comprendre ce qui s'est mal passé. Sans logs, vous êtes comme un pilote sans instruments. La journalisation est le processus d'enregistrement des informations sur le fonctionnement de l'application : erreurs, avertissements, messages de débogage et événements clés.

Dans cet article, nous allons examiner les meilleures pratiques de journalisation pour les développeurs débutants en C# (.NET). Vous apprendrez comment configurer la journalisation, quels outils utiliser et comment éviter les erreurs typiques.

1. Choix de l'outil de journalisation en C#

Dans l'écosystème .NET, il existe plusieurs bibliothèques populaires pour la journalisation. Pour les débutants, nous recommandons trois options principales :

1.1. ILogger intégré (Microsoft.Extensions.Logging)

Depuis .NET Core, Microsoft fournit une interface intégrée ILogger. Elle est simple à utiliser et ne nécessite pas l'installation de bibliothèques tierces.

using Microsoft.Extensions.Logging;\n\npublic class OrderService\n{\n    private readonly ILogger<OrderService> _logger;\n\n    public OrderService(ILogger<OrderService> logger)\n    {\n        _logger = logger;\n    }\n\n    public void ProcessOrder(int orderId)\n    {\n        _logger.LogInformation("Traitement de la commande {OrderId}", orderId);\n        // Logique de traitement\n    }\n}

1.2. Serilog — flexible et puissant

Serilog est l'une des bibliothèques les plus populaires. Elle prend en charge la journalisation structurée, ce qui permet d'analyser facilement les données. Installation via NuGet : Install-Package Serilog.AspNetCore

using Serilog;\n\npublic class Program\n{\n    public static void Main(string[] args)\n    {\n        Log.Logger = new LoggerConfiguration()\n            .MinimumLevel.Debug()\n            .WriteTo.Console()\n            .WriteTo.File("logs/app.log", rollingInterval: RollingInterval.Day)\n            .CreateLogger();\n\n        try\n        {\n            Log.Information("Application démarrée");\n            CreateHostBuilder(args).Build().Run();\n        }\n        catch (Exception ex)\n        {\n            Log.Fatal(ex, "L'application s'est terminée avec une erreur");\n        }\n        finally\n        {\n            Log.CloseAndFlush();\n        }\n    }\n}

1.3. NLog — le choix classique

NLog est une autre bibliothèque mature offrant de vastes possibilités de configuration via des fichiers de configuration.

// Configuration via appsettings.json\n{\n  "NLog": {\n    "targets": {\n      "console": {\n        "type": "Console",\n        "layout": "${longdate}|${level:uppercase=true}|${message}"\n      },\n      "file": {\n        "type": "File",\n        "fileName": "logs/app.log",\n        "layout": "${longdate}|${level:uppercase=true}|${message}"\n      }\n    },\n    "rules": [\n      { "logger": "*", "minLevel": "Info", "writeTo": "console,file" }\n    ]\n  }\n}

2. Niveaux de journalisation : quand utiliser quoi

L'utilisation correcte des niveaux de journalisation est la base d'une bonne pratique. En C# (.NET), les niveaux suivants sont définis (du plus critique au moins critique) :

\n
• Trace (0) — informations de débogage extrêmement détaillées. Utilisé uniquement pour un diagnostic approfondi.
\n
• Debug (1) — messages de débogage pour les développeurs. Activé dans l'environnement de développement, mais désactivé en production.
\n
• Information (2) — messages d'information généraux sur le fonctionnement de l'application (démarrage, opérations réussies).
\n
• Warning (3) — avertissements concernant des problèmes potentiels qui ne sont pas des erreurs (par exemple, dépassement du temps d'exécution).
\n
• Error (4) — erreurs qui nécessitent une attention particulière mais ne sont pas fatales pour l'application.
\n
• Critical (5) — erreurs critiques après lesquelles l'application