Comment annoter un PDF avec GroupDocs Annotation .NET (C#)

Vous avez déjà eu besoin de comment annoter un pdf de façon programmatique et vous vous êtes demandé quelle bibliothèque vous offre à la fois puissance et simplicité ? Que vous construisiez une plateforme de révision juridique, un système d’e‑learning ou un flux de travail collaboratif sur les documents, GroupDocs.Annotation .NET fournit une API prête pour la production qui vous permet d’ajouter, modifier et supprimer des annotations PDF directement depuis du code C#. Dans ce guide, vous apprendrez tout ce qu’il faut pour implémenter un moteur d’annotation complet, de la configuration initiale à l’optimisation des performances pour d’immenses bibliothèques de documents.

Réponses rapides

  • Quelle est la façon la plus rapide d’ajouter une note texte à un PDF ? Chargez le document avec Annotator, créez un TextAnnotation, définissez son Box et son Message, puis appelez Add() – le tout en moins d’une seconde pour des pages classiques.
  • Quelles versions .NET sont prises en charge ? .NET Framework 4.6.1+, .NET Core 2.0+, .NET 5, .NET 6 et .NET 7.
  • Ai‑je besoin d’une licence pour la production ? Oui – une licence complète ou temporaire supprime les filigranes et débloque toutes les fonctionnalités.
  • Puis‑je traiter des PDF de 200 pages sur un serveur de 4 Go ? Oui, en utilisant le traitement par lots et les modèles de libération appropriés présentés plus loin.
  • GroupDocs.Annotation convient‑il à l’annotation de documents juridiques ? Absolument – il prend en charge plus de 50 formats, un contrôle granulaire des permissions et des métadonnées prêtes pour l’audit.

Qu’est‑ce que le “comment annoter pdf” ?

« Comment annoter pdf » désigne le processus d’ajout programmatique de repères — commentaires, surlignages, formes ou redactions — aux fichiers PDF. Avec GroupDocs.Annotation .NET, vous pouvez automatiser ce flux de travail, stocker les données d’annotation dans des bases de données et rendre les résultats instantanément dans des visionneuses web ou desktop.

Pourquoi utiliser GroupDocs.Annotation pour le marquage PDF ?

GroupDocs.Annotation prend en charge plus de 50 formats d’entrée et de sortie, peut gérer des PDF jusqu’à 500 Mo sans charger le fichier complet en mémoire, et offre des opérations thread‑safe lorsqu’une requête crée sa propre instance Annotator. Comparé aux bibliothèques légères uniquement PDF, il vous permet également d’annoter Word, PowerPoint et des images avec la même API, ce qui réduit considérablement l’effort de développement pour des plateformes multi‑format.

Applications concrètes : où l’annotation de documents brille

Comprendre le contexte métier vous aide à choisir le bon type d’annotation.

  • Revue de documents juridiques – Les avocats ajoutent des commentaires, surlignent des clauses et joignent des historiques de révision. GroupDocs.Annotation suit chaque modification avec les identifiants d’utilisateur, les horodatages et des signatures numériques optionnelles pour la conformité d’audit.
  • Plateformes éducatives – Les formateurs peuvent noter les devoirs en dessinant des formes, en ajoutant des notes autocollantes ou en intégrant des retours audio directement sur les PDF des étudiants.
  • Documentation médicale – Les cliniciens annotent les rapports de radiologie ou les dossiers patients tout en conservant des métadonnées conformes à la HIPAA.
  • Documentation logicielle – Les rédacteurs techniques collaborent sur les spécifications d’API, insérant des encadrés et des notes de révision sans quitter le PDF source.
  • Services financiers – Les agents de conformité annotent les contrats de prêt, les évaluations de risque et les pistes d’audit, puis exportent la version annotée pour l’archivage.

Prérequis et configuration : préparer votre environnement

Exigences système

  • IDE : Visual Studio 2019 ou ultérieur (l’édition Community convient).
  • Runtime : .NET Framework 4.6.1+ ou .NET Core 2.0+ (8 Go de RAM recommandés pour les gros PDF).
  • Permissions : accès en écriture au dossier où les PDF annotés seront enregistrés.

Prérequis de connaissances

  • Syntaxe C# de base et concepts orientés objet.
  • Familiarité avec la gestion des packages NuGet.
  • Compréhension des I/O de fichiers (lecture/écriture de flux).

Installation de GroupDocs.Annotation .NET

Vous pouvez ajouter la bibliothèque via NuGet. Choisissez la méthode qui correspond à votre flux de travail.

Utilisation de la console du gestionnaire de packages NuGet

Install-Package GroupDocs.Annotation -Version 25.4.0

Utilisation de .NET CLI (préféré pour les pipelines CI/CD)

dotnet add package GroupDocs.Annotation --version 25.4.0

Astuce pro : Toujours épingler la version (par ex., Install-Package GroupDocs.Annotation -Version 23.12). Cela empêche les changements incompatibles accidentels lors des mises à jour automatiques du package. Consultez les dernières versions sur la page des releases GroupDocs.

Options de licence : choisissez ce qui convient à votre projet

  • Essai gratuit – Fonctionnalités complètes avec filigranes d’évaluation pendant 30 jours.
  • Licence temporaire – Supprime les filigranes pendant 30 jours, idéal pour les preuves de concept. Voir la page de licence temporaire.
  • Licence complète – Utilisation illimitée en production, support prioritaire et aucun filigrane. Achetez via la boutique GroupDocs.

Configuration de base du projet

Créez un nouveau projet console C# ou ASP.NET et ajoutez les instructions using suivantes après l’installation du package :

using GroupDocs.Annotation;
using GroupDocs.Annotation.Models;
using GroupDocs.Annotation.Models.AnnotationModels;
using System.IO;
using System.Collections.Generic;

// Initialize Annotator with an input document path
string inputPath = Path.Combine("YOUR_DOCUMENT_DIRECTORY", "sample.pdf");

Important : Remplacez YOUR_DOCUMENT_DIRECTORY par le chemin absolu vers vos PDF. L’utilisation de Path.Combine garantit des séparateurs de chemin corrects sous Windows et Linux.

Tutoriel pas à pas : ajouter votre première annotation

Comment charger un document PDF pour l’annotation ?

La classe Annotator est le composant central qui charge un document et gère toutes les opérations d’annotation. Charger correctement un PDF garantit que la bibliothèque peut lire les dimensions des pages, les métadonnées et les annotations existantes avant toute modification.
Chargez le PDF avec le constructeur Annotator, en passant le chemin du fichier et les options de chargement éventuelles. Cette étape valide le fichier et prépare une représentation en mémoire que vous pouvez modifier en toute sécurité, tout en gérant les fichiers chiffrés si un mot de passe est fourni.

try 
{
    using (Annotator annotator = new Annotator(inputPath))
    {
        // Your annotation code goes here
        Console.WriteLine("Document loaded successfully!");
    }
}
catch (Exception ex)
{
    Console.WriteLine($"Error loading document: {ex.Message}");
}

Le bloc try‑catch protège contre les fichiers manquants, les PDF corrompus ou les formats non pris en charge, assurant que votre application échoue proprement au lieu de planter.

Comment ajouter une annotation texte à un PDF ?

TextAnnotation représente un commentaire de type note autocollante qui peut être placé sur une page PDF. L’ajout consiste à créer l’objet, définir son emplacement, définir le message affiché, puis l’insérer dans le document via l’Annotator.
Créez un objet TextAnnotation, définissez son rectangle de délimitation avec la propriété Box, définissez le Message visible, puis appelez Add() sur l’Annotator. L’annotation apparaît immédiatement sur la page spécifiée, et vous pouvez personnaliser son apparence avec la couleur et l’opacité si besoin.

// Create a highlight annotation
HighlightAnnotation highlight = new HighlightAnnotation
{
    Box = new Rectangle(100, 100, 200, 20), // x, y, width, height
    CreatedOn = DateTime.Now,
    Message = "This section needs review",
    Replies = new List<Reply>
    {
        new Reply
        {
            Comment = "Please verify these numbers",
            RepliedOn = DateTime.Now
        }
    }
};

// Add the annotation to the document
annotator.Add(highlight);

Pourquoi la propriété Box est importante : Le rectangle utilise des points (1 point = 1/72 pouce) mesurés depuis le coin inférieur‑gauche de la page. Des coordonnées précises vous permettent de placer les notes exactement où les relecteurs les attendent.

Comment enregistrer le PDF annoté sans écraser la source ?

Enregistrer dans un nouveau fichier préserve le document original pour les pistes d’audit et les scénarios de restauration. La méthode Save écrit toutes les modifications, y compris les nouvelles annotations et les métadonnées, vers le chemin spécifié tout en laissant la source intacte.
Appelez Save() sur l’Annotator et fournissez un nouveau chemin de fichier. Cela conserve le document original, ce qui est essentiel pour les pistes d’audit et les restaurations, et vous pouvez éventuellement spécifier un format de sortie différent si une conversion est requise.

string outputPath = Path.Combine("YOUR_OUTPUT_DIRECTORY", "annotated_document.pdf");
annotator.Save(outputPath);
Console.WriteLine($"Document saved to: {outputPath}");

Bonne pratique : Stockez les versions originales et annotées dans des dossiers distincts sous contrôle de version. Cette stratégie simplifie la conformité réglementaire et le suivi des changements.

Techniques d’annotation avancées

Comment ajouter plusieurs types d’annotation en une seule opération ?

GroupDocs.Annotation propose un ensemble riche de classes d’annotation — HighlightAnnotation, StrikeoutAnnotation, PolylineAnnotation, RedactionAnnotation, etc. En créant chaque instance, en configurant ses propriétés et en les ajoutant au même Annotator avant l’enregistrement, vous minimisez les I/O et maintenez l’état du document cohérent.
Instanciez chaque type d’annotation, définissez ses attributs spécifiques (couleur, opacité, points, …) et ajoutez‑les séquentiellement au même Annotator. Lorsque vous appelez Save(), toutes les annotations sont écrites ensemble, assurant des mises à jour atomiques et réduisant le risque d’écritures partielles.

// Text annotation for comments
TextAnnotation textNote = new TextAnnotation
{
    Box = new Rectangle(300, 200, 100, 30),
    Message = "Review required",
    CreatedOn = DateTime.Now,
    FontColor = 16711680, // Red color in RGB
    BackgroundColor = 16777215 // White background
};

// Arrow annotation to point out specific elements
ArrowAnnotation pointer = new ArrowAnnotation
{
    Box = new Rectangle(150, 150, 50, 50),
    Message = "Important calculation here",
    CreatedOn = DateTime.Now
};

// Add all annotations at once
annotator.Add(textNote);
annotator.Add(pointer);

Comment mettre à jour la couleur ou le commentaire d’une annotation existante ?

La méthode GetById récupère une annotation spécifique par son identifiant unique, vous permettant de ne modifier que les champs souhaités. Après avoir récupéré l’objet, vous pouvez changer des propriétés comme Color ou Message puis persister les changements avec Update.
Récupérez l’annotation par son Id unique avec GetById(), modifiez les propriétés désirées (par ex., Color, Message) et invoquez Update(). Cette approche évite de recréer l’annotation et préserve son positionnement d’origine, son historique de version et les réponses éventuelles.

// Get all annotations from the document
List<AnnotationBase> annotations = annotator.Get();

// Find and update a specific annotation
foreach (var annotation in annotations)
{
    if (annotation.Message.Contains("Review required"))
    {
        annotation.Message = "Review completed ✓";
        annotator.Update(annotation);
        break;
    }
}

Note de performance : Pour les documents contenant des milliers d’annotations, mettez en cache les IDs d’annotation dans un dictionnaire afin d’éviter les recherches linéaires.

Problèmes courants et dépannage

Problème 1 – « Document format not supported »

Réponse directe : Vérifiez que l’extension du fichier figure dans la liste des formats pris en charge par GroupDocs.Annotation ; sinon, convertissez le fichier en PDF d’abord ou utilisez un autre produit GroupDocs qui gère ce format.
Solution :

// Check if format is supported before processing
string extension = Path.GetExtension(inputPath).ToLower();
if (extension != ".pdf" && extension != ".docx" && extension != ".pptx")
{
    throw new NotSupportedException($"File format {extension} is not supported");
}

Problème 2 – Les annotations apparaissent aux mauvais emplacements

Réponse directe : Assurez‑vous d’utiliser le bon système de coordonnées (origine en bas‑gauche) et que les métadonnées de rotation de la page sont respectées. Ajustez les valeurs de Box en conséquence.
Solution :

// Always validate coordinates before adding annotations
private bool IsValidCoordinate(Rectangle box, double pageWidth, double pageHeight)
{
    return box.X >= 0 && box.Y >= 0 && 
           (box.X + box.Width) <= pageWidth && 
           (box.Y + box.Height) <= pageHeight;
}

Problème 3 – Problèmes de mémoire avec de gros documents

Réponse directe : Traitez les gros PDF par lots, libérez l’Annotator après chaque lot et activez le mode streaming pour éviter de charger le fichier complet en RAM.
Solution :

// Process large documents in chunks
using (Annotator annotator = new Annotator(inputPath))
{
    // Set memory-friendly options
    LoadOptions loadOptions = new LoadOptions
    {
        PreviewPageCount = 1 // Load pages on demand
    };
    
    // Process annotations in batches
    const int batchSize = 10;
    for (int i = 0; i < annotations.Count; i += batchSize)
    {
        var batch = annotations.Skip(i).Take(batchSize);
        foreach (var annotation in batch)
        {
            annotator.Add(annotation);
        }
        
        // Force garbage collection between batches for large documents
        if (i % 50 == 0)
        {
            GC.Collect();
            GC.WaitForPendingFinalizers();
        }
    }
}

Conseils d’optimisation des performances

Comment traiter par lots des milliers de PDF efficacement ?

Regroupez les requêtes d’annotation dans une liste, ouvrez un seul Annotator par document, appliquez toutes les modifications, puis appelez Save() une fois. Cela réduit la surcharge I/O, exploite le tampon interne et maintient une utilisation mémoire prévisible pour de gros volumes.
Regroupez les requêtes d’annotation dans une liste, ouvrez un seul Annotator par document, appliquez toutes les modifications, puis appelez Save() une fois. Cela réduit la surcharge I/O et exploite le tampon interne.

// Inefficient approach (don't do this)
foreach (var annotation in annotations)
{
    annotator.Add(annotation);
    annotator.Save(outputPath); // Saving after each annotation is expensive
}

// Efficient approach
foreach (var annotation in annotations)
{
    annotator.Add(annotation);
}
annotator.Save(outputPath); // Save once at the end

Comment gérer la mémoire avec des PDF de plusieurs centaines de pages ?

Activez le drapeau MemoryOptimization = true dans LoadOptions et traitez les pages séquentiellement. Cela indique à la bibliothèque de ne garder en mémoire que la page active, réduisant drastiquement l’empreinte RAM pour les fichiers très volumineux.
Activez le drapeau MemoryOptimization = true dans LoadOptions et traitez les pages séquentiellement. Cela indique à la bibliothèque de ne garder en mémoire que la page active, réduisant drastiquement l’empreinte RAM pour les fichiers très volumineux.

// Use using statements to ensure proper disposal
using (var annotator = new Annotator(inputPath))
{
    // Your annotation code here
} // Annotator is automatically disposed, freeing memory

Comment mettre en cache les documents fréquemment consultés ?

Stockez le JSON d’annotation sérialisé dans un cache distribué (par ex., Redis) avec comme clé l’ID du document. Lorsqu’un utilisateur demande le même PDF, récupérez l’ensemble d’annotations mis en cache au lieu de relire le fichier disque, ce qui coupe la latence et la charge I/O.
Stockez le JSON d’annotation sérialisé dans un cache distribué (par ex., Redis) avec comme clé l’ID du document. Lorsqu’un utilisateur demande le même PDF, récupérez l’ensemble d’annotations mis en cache au lieu de relire le fichier disque, ce qui coupe la latence et la charge I/O.

// Cache document metadata to avoid reloading
private static readonly Dictionary<string, DocumentInfo> _documentCache = 
    new Dictionary<string, DocumentInfo>();

private DocumentInfo GetDocumentInfo(string path)
{
    if (!_documentCache.ContainsKey(path))
    {
        using (var annotator = new Annotator(path))
        {
            _documentCache[path] = annotator.GetDocumentInfo();
        }
    }
    return _documentCache[path];
}

Bonnes pratiques pour les applications en production

Comment implémenter une gestion robuste des erreurs et des logs ?

Enveloppez chaque opération Annotator dans des blocs try‑catch, consignez les exceptions avec un logger structuré (Serilog, NLog) et incluez le chemin du document, l’ID utilisateur et la trace de la pile. Cela facilite grandement le dépannage en production et aide à satisfaire les exigences d’audit.
Enveloppez chaque opération Annotator dans des blocs try‑catch, consignez les exceptions avec un logger structuré (Serilog, NLog) et incluez le chemin du document, l’ID utilisateur et la trace de la pile.

public async Task<bool> AddAnnotationSafely(string documentPath, AnnotationBase annotation)
{
    try
    {
        using (var annotator = new Annotator(documentPath))
        {
            annotator.Add(annotation);
            annotator.Save(documentPath.Replace(".pdf", "_annotated.pdf"));
            return true;
        }
    }
    catch (Exception ex)
    {
        // Log the error (use your preferred logging framework)
        Console.WriteLine($"Annotation failed for {documentPath}: {ex.Message}");
        return false;
    }
}

Comment valider les données d’annotation fournies par l’utilisateur ?

Vérifiez que les champs JSON entrants (numéro de page, coordonnées du rectangle, type d’annotation) sont dans les limites acceptables avant de créer les objets d’annotation. Rejetez les coordonnées hors limites avec une réponse HTTP 400 claire et fournissez un message d’erreur explicite.
Vérifiez que les champs JSON entrants (numéro de page, coordonnées du rectangle, type d’annotation) sont dans les limites acceptables avant de créer les objets d’annotation. Rejetez les coordonnées hors limites avec une réponse HTTP 400 claire et fournissez un message d’erreur explicite.

public bool ValidateAnnotationInput(AnnotationBase annotation)
{
    if (annotation == null)
        return false;
    
    if (string.IsNullOrWhiteSpace(annotation.Message))
        return false;
    
    if (annotation.Box.Width <= 0 || annotation.Box.Height <= 0)
        return false;
    
    return true;
}

Comment garantir la sécurité des threads dans un service web multi‑utilisateur ?

Instanciez un nouvel Annotator par requête ; ne partagez jamais une même instance entre plusieurs threads. Si vous devez coordonner l’accès à un fichier partagé, utilisez un SemaphoreSlim ou un verrou au niveau du fichier pour empêcher les écritures concurrentes.
Instanciez un nouvel Annotator par requête ; ne partagez jamais une même instance entre plusieurs threads.

private readonly object _annotationLock = new object();

public void AddAnnotationThreadSafe(string documentPath, AnnotationBase annotation)
{
    lock (_annotationLock)
    {
        using (var annotator = new Annotator(documentPath))
        {
            annotator.Add(annotation);
            annotator.Save(documentPath);
        }
    }
}

Quand choisir GroupDocs.Annotation plutôt que des alternatives

Choisissez GroupDocs.Annotation lorsque vous avez besoin de :

  • Support multi‑format (PDF, DOCX, PPTX, images).
  • Types d’annotation avancés tels que la redaction, le dessin à main levée et les métadonnées personnalisées.
  • Licence entreprise, support SLA et mises à jour de sécurité régulières.

Envisagez des alternatives plus légères lorsque vous ne travaillez qu’avec des PDF, que votre budget est très limité ou que vous avez besoin d’une pile open‑source.

FAQ

Q : Puis‑je utiliser GroupDocs.Annotation .NET sans licence ?
R : Oui, l’essai gratuit offre toutes les fonctionnalités pendant 30 jours mais ajoute des filigranes d’évaluation à chaque fichier de sortie. Pour tout déploiement en production, vous devez appliquer une licence temporaire ou complète afin de supprimer ces filigranes.

Q : Quelles versions .NET sont prises en charge par GroupDocs.Annotation ?
R : La bibliothèque fonctionne avec .NET Framework 4.6.1+, .NET Core 2.0+, .NET 5, .NET 6 et .NET 7, ce qui la rend adaptée aux services Windows hérités comme aux conteneurs multiplateformes modernes.

Q : Combien coûte GroupDocs.Annotation .NET ?
R : Les tarifs débutent autour de 1 999 $ pour une licence développeur et augmentent en fonction du nombre d’applications déployées. Consultez la page de tarification GroupDocs pour les tarifs actuels et les remises par volume.

Q : Quels formats de documents puis‑je annoter avec GroupDocs.Annotation ?
R : Plus de 50 formats sont supportés, dont PDF, DOC/DOCX, PPT/PPTX, XLS/XLSX, JPEG, PNG, TIFF, et bien d’autres. Le PDF bénéficie du jeu de fonctionnalités le plus complet, incluant les formes vectorielles et la redaction prête pour l’OCR.

Q : Puis‑je annoter des PDF protégés par mot de passe ?
R : Oui. Fournissez le mot de passe lors de la construction de l’Annotator :

LoadOptions loadOptions = new LoadOptions { Password = "your_password" };
using (Annotator annotator = new Annotator(inputPath, loadOptions))
{
    // Your annotation code here
}

Q : Pourquoi mes annotations apparaissent‑elles au mauvais endroit ?
R : GroupDocs utilise un système de coordonnées cartésien où (0,0) se trouve en bas‑gauche et les mesures sont en points. Un mauvais positionnement provient généralement de l’utilisation de valeurs en pixels ou de l’ignorance de la rotation de la page. Convertissez les pixels en points (1 pixel ≈ 0,75 point à 96 DPI) et ajustez la rotation éventuelle.

// Correct approach - validate coordinates
private bool ValidateCoordinates(Rectangle box, double pageWidth, double pageHeight)
{
    return box.X >= 0 && box.Y >= 0 && 
           (box.X + box.Width) <= pageWidth && 
           (box.Y + box.Height) <= pageHeight;
}

Q : Comment récupérer les annotations existantes d’un PDF ?
R : Appelez la méthode Get() sur l’instance Annotator ; elle renvoie une collection de tous les objets d’annotation avec leurs IDs, types et métadonnées.

using (Annotator annotator = new Annotator(inputPath))
{
    List<AnnotationBase> annotations = annotator.Get();
    foreach (var annotation in annotations)
    {
        Console.WriteLine($"Annotation: {annotation.Message}");
    }
}

Q : Puis‑je supprimer des annotations spécifiques par programme ?
R : Oui. Utilisez Delete(id) pour supprimer une annotation unique ou DeleteAll() pour nettoyer entièrement le document. Vous pouvez également filtrer par type avant la suppression.

List<AnnotationBase> annotationsToDelete = annotator.Get()
    .Where(a => a.Message.Contains("obsolete"))
    .ToList();

foreach (var annotation in annotationsToDelete)
{
    annotator.Remove(annotation);
}

Q : Comment mettre à jour les propriétés d’une annotation comme la couleur ou le message ?
R : Récupérez l’annotation, modifiez Color ou Message, puis invoquez Update(). Le changement sera persistant lors du prochain appel à Save().

var annotations = annotator.Get();
var targetAnnotation = annotations.FirstOrDefault(a => a.Id == specificId);
if (targetAnnotation != null)
{
    targetAnnotation.Message = "Updated message";
    annotator.Update(targetAnnotation);
}

Q : Puis‑je ajouter des métadonnées personnalisées aux annotations ?
R : Absolument. La plupart des classes d’annotation exposent une collection Replies où vous pouvez stocker des paires clé‑valeur, vous permettant d’attacher des IDs de relecteur, des horodatages ou des états de workflow.

var annotation = new HighlightAnnotation
{
    // ... other properties
    Replies = new List<Reply>
    {
        new Reply
        {
            Comment = "Custom metadata: priority=high, category=legal",
            RepliedOn = DateTime.Now
        }
    }
};

Q : GroupDocs.Annotation prend‑il en charge les signatures numériques sur les PDF annotés ?
R : Bien que la bibliothèque d’annotation se concentre sur le marquage, vous pouvez la combiner avec GroupDocs.Signature .NET pour appliquer des signatures cryptographiques après les annotations, assurant à la fois l’intégrité visuelle et légale.

Q : Puis‑je exporter les annotations vers JSON ou XML pour un traitement externe ?
R : La bibliothèque ne fournit pas d’exportateur intégré, mais vous pouvez sérialiser vous‑même les objets d’annotation avec System.Text.Json ou XmlSerializer. Cela facilite l’intégration avec des systèmes d’audit externes.

List<AnnotationBase> annotations = annotator.Get();
string jsonAnnotations = JsonConvert.SerializeObject(annotations, Formatting.Indented);
File.WriteAllText("annotations.json", jsonAnnotations);

Dernière mise à jour : 2026-05-21
Testé avec : GroupDocs.Annotation 23.12 pour .NET
Auteur : GroupDocs

Tutoriels associés