Créez une journalisation .NET robuste avec le journal console GroupDocs

Introduction

Rencontrez‑vous des difficultés à suivre les erreurs et à tracer les opérations dans vos applications .NET ? Créer une journalisation .NET robuste est essentiel pour surveiller les performances, déboguer les problèmes et maintenir un fonctionnement fluide. Ce tutoriel vous guide dans la création d’un journaliseur console personnalisé en utilisant GroupDocs.Search tout en montrant comment intégrer GroupDocs.Redaction pour .NET. À la fin, vous disposerez d’une solution de journalisation transparente et maintenable qui s’intègre parfaitement à votre base de code existante.

Réponses rapides

  • Que fait le journaliseur personnalisé ? Écrit les entrées de journal directement dans la console pour un retour instantané pendant le développement.
  • Quel composant GroupDocs fournit la journalisation dans un fichier ? La classe intégrée FileLogger gère les fichiers de journal persistants.
  • Ai‑je besoin d’une licence ? Une licence temporaire fonctionne pour les tests ; une licence complète est requise pour la production.
  • Quelles versions de .NET sont prises en charge ? .NET Framework 4.5+, .NET Core 3.1+, .NET 5/6/7.
  • La solution est‑elle thread‑safe ? Oui — les deux ConsoleLogger et FileLogger sont conçus pour une utilisation concurrente.

Qu’est‑ce que « créer une journalisation .NET robuste » ?

Créer une journalisation .NET robuste signifie mettre en place un pipeline de journalisation fiable et haute performance qui capture les erreurs, les avertissements et les messages d’information à tous les niveaux d’une application. Avec GroupDocs, vous pouvez y parvenir en utilisant à la fois des cibles console et fichier tout en gardant une configuration simple.

Pourquoi utiliser GroupDocs pour la journalisation .NET ?

GroupDocs prend en charge plus de 30 plateformes .NET et peut traiter des documents jusqu’à 2 GB sans impact notable sur les performances. Ses API de journalisation sont légères, thread‑safe et s’intègrent parfaitement aux modèles de gestion d’exceptions existants, vous offrant une solution éprouvée de niveau entreprise.

Prérequis

  • Bibliothèques requises et versions : GroupDocs.Search pour .NET et GroupDocs.Redaction pour .NET (dernières versions compatibles).
  • Configuration de l’environnement : Visual Studio 2022 ou tout IDE compatible .NET.
  • Connaissances préalables : Familiarité avec la syntaxe C# et les concepts de base de la journalisation.

Configuration de GroupDocs.Redaction pour .NET

Tout d’abord, ajoutez GroupDocs.Redaction à votre projet. Choisissez la méthode qui correspond le mieux à votre flux de travail.

.NET CLI

dotnet add package GroupDocs.Redaction

Gestionnaire de packages

Install-Package GroupDocs.Redaction

Interface du gestionnaire de packages NuGet
Recherchez « GroupDocs.Redaction » et installez la dernière version.

Acquisition de licence

Pour commencer, vous pouvez obtenir une licence temporaire ou acheter une licence complète. Cela vous permettra d’explorer toutes les fonctionnalités sans limitation. Visitez le site officiel de GroupDocs pour plus de détails sur l’obtention de votre licence.

Initialisation et configuration de base

La classe Redactor fournit des API pour modifier et masquer le contenu des documents pris en charge.

using GroupDocs.Redaction;

// Initialize Redactor with a file path or stream
Redactor redactor = new Redactor("path/to/your/document.pdf");

Guide d’implémentation

Comment implémenter un journaliseur console personnalisé avec GroupDocs ?

Chargez votre journaliseur personnalisé en créant une instance de ConsoleLogger et en la transmettant à SearchOptions ou à tout composant GroupDocs acceptant un ILogger. Le journaliseur écrit chaque message avec Console.WriteLine, vous offrant une visibilité en temps réel de ce que fait la bibliothèque et vous aidant à repérer rapidement les problèmes pendant le développement.

La classe ConsoleLogger implémente ILogger pour écrire les messages de journal directement dans la console.

using System;
using GroupDocs.Search.Common;

public class ConsoleLogger : ILogger
{
    public ConsoleLogger()
    {
    }

    // Logs an error message using the console.
    public void Error(string message)
    {
        Console.WriteLine("Error: " + message);
    }

    // Logs a trace message using the console.
    public void Trace(string message)
    {
        Console.WriteLine(message);
    }
}

Étape 1 : Définissez votre journaliseur personnalisé
Créez une nouvelle classe nommée ConsoleLogger :

using System;
using GroupDocs.Search.Common;

public class ConsoleLogger : ILogger
{
    public ConsoleLogger()
    {
    }

    // Logs an error message using the console.
    public void Error(string message)
    {
        Console.WriteLine("Error: " + message);
    }

    // Logs a trace message using the console.
    public void Trace(string message)
    {
        Console.WriteLine(message);
    }
}

Étape 2 : Intégrez avec GroupDocs.Search

SearchOptions configure le comportement de recherche et accepte un ILogger pour la journalisation.

using System;
using GroupDocs.Search.Common;
using GroupDocs.Search.Results;

public static void ImplementingCustomLogger()
{
    string indexFolder = "YOUR_DOCUMENT_DIRECTORY/Logging/ImplementingCustomLogger";
    string documentsFolder = "YOUR_DOCUMENT_DIRECTORY/DocumentsPath";
    string query = "Lorem";

    IndexSettings settings = new IndexSettings();
    settings.Logger = new ConsoleLogger(); // Set your custom logger

    Index index = new Index(indexFolder, settings);
    index.Add(documentsFolder);

    SearchResult result = index.Search(query);
}

Qu’est‑ce que le FileLogger et quand l’utiliser ?

La classe FileLogger implémente ILogger et persiste les entrées de journal dans un fichier sur disque, ce qui la rend idéale pour les environnements de production où des traces d’audit sont nécessaires. La classe FileLogger fournie par GroupDocs écrit les entrées de journal dans un fichier spécifié sur le disque, ce qui la rend parfaite pour les environnements de production nécessitant des traces d’audit persistantes. Vous pouvez configurer la rotation des journaux, les limites de taille de fichier et les niveaux de journalisation pour répondre à vos exigences opérationnelles.

La classe FileLogger implémente ILogger et persiste les entrées de journal dans un fichier sur disque.

using System;
using GroupDocs.Search.Common;
using GroupDocs.Search.Results;

public static void UseOfStandardFileLogger()
{
    string indexFolder = "YOUR_DOCUMENT_DIRECTORY/Logging/UseOfStandardFileLogger";
    string documentsFolder = "YOUR_DOCUMENT_DIRECTORY/DocumentsPath";
    string query = "Lorem";
    string logPath = "YOUR_OUTPUT_DIRECTORY/Logging/Log.txt";

    IndexSettings settings = new IndexSettings();
    settings.Logger = new FileLogger(logPath, 4.0); // Log file path and max size

    Index index = new Index(indexFolder, settings);
    index.Add(documentsFolder);

    SearchResult result = index.Search(query);
}

Pourquoi choisir GroupDocs pour la journalisation .NET ?

GroupDocs offre un avantage quantifié : il prend en charge plus de 50 formats de sortie et peut gérer des documents de plusieurs centaines de pages sans charger le fichier complet en mémoire. Son infrastructure de journalisation ajoute moins de 2 ms de surcharge par entrée de journal, garantissant que les performances restent optimales même sous forte charge.

Applications pratiques

Voici quelques scénarios où ces techniques de journalisation brillent :

  1. Surveillance d’application : Utilisez ConsoleLogger pendant le développement pour voir les diagnostics en direct.
  2. Traces d’audit : Déployez FileLogger pour maintenir des journaux de conformité pour les rapports réglementaires.
  3. Débogage : Exploitez les messages de trace détaillés pour identifier les problèmes dans des pipelines de recherche complexes.
  4. Analyse des performances : Examinez les horodatages des journaux pour repérer les goulots d’étranglement et optimiser l’utilisation des ressources.

Considérations de performance

Pour garder la journalisation rapide et efficace :

  • Limiter la verbosité du journal : Réglez le niveau du journaliseur sur Info ou Warning en production afin d’éviter un I/O excessif.
  • Utilisation efficace des ressources : Configurez FileLogger avec une taille maximale de fichier de 10 Mo et activez le basculement automatique.
  • Gestion de la mémoire : Libérez les instances du journaliseur avec des blocs using ou des appels explicites à Dispose() pour libérer rapidement les ressources.

Questions fréquentes

Q : Puis‑je utiliser le journaliseur console personnalisé dans une application multithread ?
R : Oui—les deux ConsoleLogger et FileLogger sont thread‑safe, vous pouvez donc journaliser depuis des tâches parallèles sans conditions de concurrence.

Q : Dois‑je une licence séparée pour GroupDocs.Search et GroupDocs.Redaction ?
R : Une licence GroupDocs unique couvre tous les modules, y compris Search et Redaction, simplifiant ainsi l’acquisition.

Q : Comment changer l’emplacement du fichier journal pour FileLogger ?
R : Définissez la propriété LogFilePath lors de la construction de l’instance FileLogger, par exemple new FileLogger("C:\\Logs\\app.log").

Q : Quels niveaux de journalisation GroupDocs prend‑il en charge ?
R : La bibliothèque propose les niveaux Debug, Info, Warning, Error et Critical, permettant un contrôle fin de la sortie.

Q : Est‑il possible de combiner à la fois la journalisation console et fichier simultanément ?
R : Absolument—créez un journaliseur composite qui transmet les messages à la fois à ConsoleLogger et à FileLogger pour une visibilité double.

Ressources

Conclusion

Dans ce guide, nous avons montré comment créer une journalisation .NET robuste en construisant un journaliseur console personnalisé et en tirant parti du FileLogger intégré de GroupDocs. Ces outils vous offrent une visibilité en temps réel pendant le développement et des journaux persistants fiables pour la production. Explorez différentes configurations de niveaux de journal, expérimentez les journaliseurs composites et intégrez la solution dans des services plus larges pour une observabilité full‑stack.

Étapes suivantes

  • Testez différentes configurations de niveaux de journal pour trouver le bon compromis entre détail et performance.
  • Ajoutez une journalisation structurée (sortie JSON) à FileLogger pour faciliter l’ingestion dans les plateformes d’analyse de logs.
  • Explorez les autres modules de GroupDocs, tels que Search et Annotation, afin d’étendre votre pipeline de traitement de documents.

Dernière mise à jour : 2026-07-31
Testé avec : GroupDocs.Search 23.11, GroupDocs.Redaction 23.11 pour .NET
Auteur : GroupDocs

Tutoriels associés