Implémenter un logger personnalisé c# dans GroupDocs.Redaction pour .NET

Gérer efficacement les redactions de documents est crucial, surtout lorsqu’il s’agit d’informations sensibles. Dans ce guide, vous apprendrez comment implémenter un logger personnalisé c# avec GroupDocs.Redaction pour .NET, vous offrant un contrôle total sur la journalisation, la gestion des erreurs et les pistes d’audit. À la fin du tutoriel, vous serez capable de capturer les avertissements, les erreurs et les messages d’information, d’intégrer le logger aux frameworks de journalisation .NET existants, et d’enregistrer le document redacté sans rasterisation.

Réponses rapides

  • Que fait un logger personnalisé c# ? Il capture les erreurs, les avertissements et les messages d’information pendant la rédaction, vous offrant une piste d’audit consultable.
  • Quelle bibliothèque fournit l’interface ILogger ? GroupDocs.Redaction pour .NET fournit l’interface ILogger.
  • Puis-je enregistrer le document redacté sans rasterisation ? Oui – appelez redactor.Save(..., new Options.RasterizationOptions { Enabled = false }).
  • Ai-je besoin d’une licence pour une utilisation en production ? Une licence complète est requise pour la production ; une licence d’essai est disponible pour l’évaluation.
  • Cette approche est‑elle compatible avec .NET Core / .NET 6+ ? Absolument – la même API fonctionne sur .NET Framework, .NET Core, .NET 5 et .NET 6.

Qu’est‑ce qu’un logger personnalisé c# ?

Un logger personnalisé c# est une classe qui implémente l’interface ILogger fournie par GroupDocs.Redaction. Il vous permet de diriger les messages de journalisation où vous le souhaitez — console, fichier, base de données ou systèmes de surveillance externes — tout en vous offrant une vue claire du flux de travail de la rédaction.

Pourquoi utiliser la journalisation personnalisée .net avec GroupDocs.Redaction ?

Chargez votre processus de rédaction avec des journaux détaillés et consultables qui satisfont les audits réglementaires et accélèrent le dépannage. GroupDocs.Redaction prend en charge plus de 70 formats d’entrée et de sortie et peut traiter des documents jusqu’à 500 pages sans charger le fichier complet en mémoire, de sorte qu’un logger bien conçu ajoute une surcharge négligeable tout en offrant une visibilité inestimable.

Prérequis

  • GroupDocs.Redaction pour .NET installé (voir la section Installation ci‑dessous).
  • Un environnement de développement .NET (Visual Studio, VS Code ou le .NET CLI).
  • Connaissances de base en C# et familiarité avec les flux de fichiers.

Installation

.NET CLI

dotnet add package GroupDocs.Redaction

Package Manager

Install-Package GroupDocs.Redaction

NuGet Package Manager UI
Recherchez “GroupDocs.Redaction” et installez la dernière version.

Acquisition de licence

  • Essai gratuit : Testez l’API avec une licence temporaire.
  • Licence temporaire : Obtenez un accès complet aux fonctionnalités pendant une période limitée.
  • Achat : Obtenez une licence perpétuelle pour les déploiements en production.

Guide étape par étape

Comment implémenter un logger personnalisé dans .NET Core ?

Chargez la classe CustomLogger dans votre projet .NET Core et associez‑la aux RedactorSettings. Le logger fonctionne de la même manière sur .NET Framework, .NET 5 et .NET 6, vous permettant de partager le même code sur toutes les plateformes.

Étape 1 : Définir une classe de logger personnalisée (log warnings c#)

La classe CustomLogger implémente ILogger.
CustomLogger est une classe définie par l’utilisateur qui implémente l’interface ILogger pour capturer les événements de rédaction.

using System;
using GroupDocs.Redaction;

class CustomLogger : ILogger
{
    public bool HasErrors { get; private set; }

    // Log errors encountered during processing.
    public void LogError(string message)
    {
        Console.WriteLine("Error: " + message);
        HasErrors = true;
    }

    // Log warnings that may not be critical but need attention.
    public void LogWarning(string message)
    {
        Console.WriteLine("Warning: " + message);
    }

    // Log informational messages for tracking normal operations.
    public void LogInfo(string message)
    {
        Console.WriteLine("Info: " + message);
    }
}

Ancre de définition : CustomLogger est une implémentation définie par l’utilisateur de l’interface ILogger qui enregistre les événements de rédaction.
Explication : Le drapeau HasErrors vous aide à décider s’il faut poursuivre le traitement. Les trois méthodes correspondent aux trois niveaux de journalisation dont vous aurez besoin dans la plupart des scénarios de rédaction.

Étape 2 : Préparer les chemins de fichiers et ouvrir le document source

string sourceFile = Utils.PrepareOutputDirectory("YOUR_DOCUMENT_DIRECTORY");
string outputFile = Utils.GetOutputFile(sourceFile);

Ancre de définition : Redactor est la classe principale de GroupDocs.Redaction qui effectue les opérations de rédaction sur un document PDF.
Pourquoi c’est important : L’utilisation de méthodes utilitaires garde votre code propre et garantit que le dossier de sortie existe avant que vous ne tentiez d’enregistrer le document redacté.

Étape 3 : Appliquer les redactions en utilisant le logger personnalisé

using (Stream stream = File.Open(sourceFile, FileMode.Open, FileAccess.ReadWrite))
{
    var logger = new CustomLogger();
    
    using (Redactor redactor = new Redactor(stream, new LoadOptions(), new RedactorSettings(logger)))
    {
        // Apply a redaction to the document.
        redactor.Apply(new DeleteAnnotationRedaction());
        
        if (!logger.HasErrors)
        {
            using (Stream streamOut = File.Open(outputFile, FileMode.OpenOrCreate, FileAccess.ReadWrite))
            {
                // Save changes without rasterizing the output.
                redactor.Save(streamOut, new Options.RasterizationOptions { Enabled = false });
            }
        }
    }
}

Réponse directe : Le flux de travail de rédaction commence par créer une instance Redactor avec RedactorSettings(logger), puis en appliquant les objets de rédaction, en vérifiant logger.HasErrors, et enfin en appelant redactor.Save avec la rasterisation désactivée. Ce modèle assure que chaque étape est journalisée et que vous ne persistez un document propre que lorsqu’aucune erreur n’est survenue.

Explication :

  1. Le Redactor est instancié avec RedactorSettings(logger), liant votre CustomLogger.
  2. Après l’application d’une rédaction, le code vérifie logger.HasErrors. Si aucune erreur n’est survenue, le document est enregistré — démontrant la logique d’enregistrement du document redacté sans rasterisation.

Pièges courants & dépannage

  • Sortie de journal manquante : Vérifiez que chaque méthode Log* est correctement surchargée.
  • Exceptions d’accès aux fichiers : Assurez‑vous que l’application dispose des permissions de lecture/écriture pour les chemins source et de sortie.
  • Logger non connecté : Le paramètre RedactorSettings(logger) est essentiel ; l’omettre désactive la journalisation personnalisée.

Applications pratiques

  1. Rapports de conformité : Exportez les entrées de journal vers un CSV ou une base de données pour les pistes d’audit.
  2. Suivi des erreurs : Localisez rapidement les fichiers problématiques en analysant la sortie LogError.
  3. Automatisation du flux de travail : Déclenchez des processus en aval (par ex., notifier un responsable conformité) lorsque LogWarning est invoqué.

Considérations de performance

  • Libérer les flux rapidement pour libérer la mémoire, surtout lors du traitement de gros lots.
  • Surveiller le CPU & la mémoire pendant les rédactions en masse ; envisagez de traiter les documents en parallèle avec une synchronisation soigneuse du logger.
  • Rester à jour : Les versions plus récentes de GroupDocs.Redaction incluent souvent des optimisations de performance et des hooks de journalisation supplémentaires.

Conclusion

En implémentant un logger personnalisé c#, vous obtenez une visibilité granulaire sur chaque étape du pipeline de rédaction, facilitant le respect des normes de conformité et le débogage des problèmes. L’approche présentée fonctionne parfaitement avec GroupDocs.Redaction pour .NET et peut être étendue pour s’intégrer à n’importe quel framework de journalisation .NET que vous utilisez déjà.

Questions fréquemment posées

Q : Quel est le but de la journalisation personnalisée avec GroupDocs.Redaction ?
A : La journalisation personnalisée capture les événements détaillés de rédaction, satisfait les exigences d’audit et simplifie le dépannage en exposant les erreurs et avertissements en temps réel.

Q : Comment gérer les erreurs avec un logger personnalisé ?
A : Implémentez LogError dans votre classe CustomLogger ; le drapeau HasErrors vous permet d’interrompre le traitement si un problème critique est détecté.

Q : La journalisation personnalisée peut‑elle être intégrée à d’autres systèmes ?
A : Oui — vous pouvez transmettre les messages de journal à un CRM, ERP ou à des outils de surveillance centralisés en étendant les méthodes du logger.

Q : Quels sont les pièges courants lors de l’implémentation de la journalisation personnalisée ?
A : Les surcharges de méthodes manquantes, l’oubli de passer RedactorSettings(logger), et des permissions de fichiers insuffisantes sont les problèmes les plus fréquents.

Q : En quoi la journalisation personnalisée améliore‑t‑elle les flux de travail de rédaction de documents ?
A : Des journaux détaillés offrent une visibilité en temps réel, simplifient le débogage et génèrent les pistes d’audit requises par des réglementations telles que le GDPR et le HIPAA.

Ressources

Dernière mise à jour : 2026-10-01
Testé avec : GroupDocs.Redaction 23.11 pour .NET
Auteur : GroupDocs

Tutoriels associés