Hoe PDF annoteren met GroupDocs Annotation .NET (C#)

Heb je ooit how to annotate pdf bestanden programmatically nodig gehad en je afgevraagd welke bibliotheek zowel kracht als eenvoud biedt? Of je nu een juridisch beoordelingsplatform, een e‑learning systeem of een collaboratieve documentworkflow bouwt, GroupDocs.Annotation .NET levert een productie‑klare API waarmee je PDF‑annotaties kunt toevoegen, bewerken en verwijderen rechtstreeks vanuit C#‑code. In deze gids leer je alles wat nodig is om een volledig uitgeruste annotatie‑engine te implementeren, van de eerste installatie tot prestatie‑optimalisatie voor enorme documentbibliotheken.

Snelle antwoorden

  • Wat is de snelste manier om een tekstnotitie aan een PDF toe te voegen? Laad het document met Annotator, maak een TextAnnotation, stel de Box en Message in, en roep Add() aan – alles in minder dan een seconde voor typische pagina’s.
  • Welke .NET‑versies worden ondersteund? .NET Framework 4.6.1+, .NET Core 2.0+, .NET 5, .NET 6, en .NET 7.
  • Heb ik een licentie nodig voor productie? Ja – een volledige of tijdelijke licentie verwijdert watermerken en ontgrendelt alle functies.
  • Kan ik 200‑pagina PDF’s verwerken op een server met 4 GB? Ja, door batchverwerking en juiste disposingspatronen te gebruiken zoals later getoond.
  • Is GroupDocs.Annotation geschikt voor juridische documentannotatie? Absoluut – het ondersteunt meer dan 50 formaten, gedetailleerde permissie‑controle en audit‑klare metadata.

Wat is “how to annotate pdf”?

“How to annotate pdf” verwijst naar het proces van het programmatically toevoegen van markup—zoals opmerkingen, markeringen, vormen of redactioneringen—to PDF‑bestanden. Met GroupDocs.Annotation .NET kun je deze workflow automatiseren, annotatiedata opslaan in databases en de resultaten direct weergeven in web‑ of desktop‑viewers.

Waarom GroupDocs.Annotation gebruiken voor PDF‑markup?

GroupDocs.Annotation ondersteunt meer dan 50 invoer‑ en uitvoerformaten, kan PDF’s tot 500 MB verwerken zonder het volledige bestand in het geheugen te laden, en biedt thread‑veilige bewerkingen wanneer elk verzoek zijn eigen Annotator‑instantie creëert. In vergelijking met lichtere, alleen‑PDF‑bibliotheken, kun je hiermee ook Word-, PowerPoint- en afbeeldingsbestanden annoteren met dezelfde API, wat de ontwikkelinspanning voor multi‑format platforms drastisch vermindert.

Praktijktoepassingen: Waar Documentannotatie Uitblinkt

Het begrijpen van de zakelijke context helpt je de juiste annotatietype te kiezen.

  • Juridische documentreview – Advocaten voegen opmerkingen toe, markeren clausules en voegen revisiegeschiedenissen toe. GroupDocs.Annotation houdt elke wijziging bij met gebruikers‑ID’s, tijdstempels en optionele digitale handtekeningen voor audit‑compliance.
  • Educatieve platforms – Docenten kunnen opdrachten beoordelen door vormen te tekenen, sticky notes toe te voegen of audio‑feedback direct op student‑PDF’s te embedden.
  • Gezondheidsdocumentatie – Zorgverleners annoteren radiologierapporten of patiëntendossiers terwijl ze HIPAA‑conforme metadata behouden.
  • Softwaredocumentatie – Technische schrijvers werken samen aan API‑specificaties, voegen call‑out‑boxen en revisie‑notities in zonder de bron‑PDF te verlaten.
  • Financiële diensten – Compliance‑officieren markeren leningscontracten, risico‑beoordelingen en audit‑trails, en exporteren vervolgens de geannoteerde versie voor archivering.

Vereisten en installatie: Uw omgeving gereed maken

Systeemvereisten

  • IDE: Visual Studio 2019 of later (Community‑editie werkt prima).
  • Runtime: .NET Framework 4.6.1+ of .NET Core 2.0+ (8 GB RAM aanbevolen voor grote PDF’s).
  • Permissies: Schrijftoegang tot de map waar geannoteerde PDF’s worden opgeslagen.

Kennisvereisten

  • Basis C#‑syntaxis en object‑georiënteerde concepten.
  • Bekendheid met NuGet‑pakketbeheer.
  • Begrip van bestands‑I/O (lezen/schrijven van streams).

GroupDocs.Annotation .NET installeren

Je kunt de bibliotheek toevoegen via NuGet. Kies de methode die bij je workflow past.

Using NuGet Package Manager Console

Install-Package GroupDocs.Annotation -Version 25.4.0

Using .NET CLI (preferred for CI/CD pipelines)

dotnet add package GroupDocs.Annotation --version 25.4.0

Pro Tip: Pin altijd de versie (bijv. Install-Package GroupDocs.Annotation -Version 23.12). Dit voorkomt per ongeluk brekende wijzigingen wanneer het pakket automatisch wordt bijgewerkt. Zie de nieuwste releases op de GroupDocs releases page.

Licentieopties: Kies wat bij uw project past

  • Gratis proefversie – Volledige functionaliteit met evaluatiewatermerken voor 30 dagen.
  • Tijdelijke licentie – Verwijdert watermerken voor 30 dagen, ideaal voor proof‑of‑concepts. Zie de temporary license page.
  • Volledige licentie – Onbeperkt productiegebruik, prioriteitsondersteuning en geen watermerken. Aankoop via de GroupDocs store.

Basis projectinstelling

Maak een nieuw C#‑console‑ of ASP.NET‑project aan en voeg de volgende using‑statements toe na het installeren van het pakket:

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");

Belangrijk: Vervang YOUR_DOCUMENT_DIRECTORY door het absolute pad naar uw PDF’s. Het gebruik van Path.Combine garandeert correcte pad‑scheidingstekens op Windows en Linux.

Stapsgewijze tutorial: Uw eerste annotatie toevoegen

Hoe laad ik een PDF‑document voor annotatie?

De Annotator‑klasse is de kerncomponent die een document laadt en alle annotatie‑bewerkingen beheert. Het correct laden van een PDF zorgt ervoor dat de bibliotheek paginadimensies, metadata en bestaande annotaties kan lezen voordat er wijzigingen worden aangebracht.
Laad de PDF met de Annotator‑constructor, waarbij je het bestandspad en optionele laadopties doorgeeft. Deze stap valideert het bestand en bereidt een in‑memory‑representatie voor die je veilig kunt wijzigen, terwijl versleutelde bestanden ook worden afgehandeld als een wachtwoord wordt opgegeven.

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}");
}

Het try‑catch‑blok beschermt tegen ontbrekende bestanden, corrupte PDF’s of niet‑ondersteunde formaten, waardoor je applicatie netjes faalt in plaats van te crashen.

Hoe voeg ik een tekstannotatie toe aan een PDF?

TextAnnotation vertegenwoordigt een sticky‑note‑stijl commentaar dat op een PDF‑pagina kan worden geplaatst. Het toevoegen ervan omvat het maken van het object, het definiëren van de locatie, het instellen van het weergegeven bericht, en tenslotte het invoegen in het document via de Annotator.
Maak een TextAnnotation‑object, definieer de omhullende rechthoek met de Box‑eigenschap, stel de zichtbare Message in, en roep vervolgens Add() aan op de Annotator. De annotatie verschijnt direct op de opgegeven pagina, en je kunt het uiterlijk aanpassen met kleur‑ en doorzichtigheidsinstellingen indien nodig.

// 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);

Waarom de Box‑eigenschap belangrijk is: De rechthoek gebruikt punten (1 punt = 1/72 inch) gemeten vanaf de linksonderhoek van de pagina. Precieze coördinaten laten je notities exact plaatsen waar reviewers ze verwachten.

Hoe sla ik de geannoteerde PDF op zonder de bron te overschrijven?

Opslaan naar een nieuw bestand behoudt het originele document voor audit‑trails en rollback‑scenario’s. De Save‑methode schrijft alle wijzigingen, inclusief nieuwe annotaties en metadata, naar het opgegeven pad terwijl de bron onaangeroerd blijft.
Roep Save() aan op de Annotator en geef een nieuw bestandspad op. Dit behoudt het originele document, wat essentieel is voor audit‑trails en rollback‑scenario’s, en je kunt optioneel een ander uitvoerformaat opgeven als conversie vereist is.

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

Best practice: Sla de originele en geannoteerde versies op in aparte versie‑beheerde mappen. Deze strategie vereenvoudigt regelgevende compliance en wijzigings‑tracking.

Geavanceerde annotatietechnieken

Hoe kan ik meerdere annotatietypen in één bewerking toevoegen?

GroupDocs.Annotation biedt een uitgebreide set annotatieklassen—HighlightAnnotation, StrikeoutAnnotation, PolylineAnnotation, RedactionAnnotation en meer. Door elke instantie te maken, de eigenschappen te configureren en ze toe te voegen aan dezelfde Annotator vóór het opslaan, minimaliseer je I/O en houd je de documentstatus consistent.
Instantieer elk annotatietype, stel de specifieke attributen in (kleur, doorzichtigheid, punten, enz.), en voeg ze opeenvolgend toe aan dezelfde Annotator‑instantie. Wanneer je Save() aanroept, worden alle annotaties samen geschreven, wat atomische updates garandeert en de kans op gedeeltelijke writes vermindert.

// 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);

Hoe werk ik de kleur of opmerking van een bestaande annotatie bij?

De GetById‑methode haalt een specifieke annotatie op via zijn unieke identifier, waardoor je alleen de velden kunt wijzigen die je nodig hebt. Na het ophalen van het object kun je eigenschappen zoals Color of Message aanpassen en vervolgens de wijzigingen opslaan met Update.
Haal de annotatie op via zijn unieke Id met GetById(), wijzig de gewenste eigenschappen (bijv. Color, Message), en roep Update() aan. Deze aanpak voorkomt het opnieuw creëren van de annotatie en behoudt de oorspronkelijke positionering, versiegeschiedenis en eventuele bijgevoegde reacties.

// 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;
    }
}

Prestatie‑opmerking: Voor documenten met duizenden annotaties, cache annotatie‑ID’s in een dictionary om lineaire zoekopdrachten te vermijden.

Veelvoorkomende problemen en foutopsporing

Probleem 1 – “Documentformaat niet ondersteund”

Direct antwoord: Controleer of de extensie van het bestand voorkomt in de lijst met ondersteunde formaten van GroupDocs.Annotation; zo niet, converteer het bestand eerst naar PDF of gebruik een ander GroupDocs‑product dat het formaat verwerkt.
Oplossing:

  • Controleer de ondersteunde formaten lijst
  • Gebruik GroupDocs.Conversion om niet‑ondersteunde bestanden eerst naar PDF te converteren voordat je annoteert.
// 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");
}

Probleem 2 – Annotaties verschijnen op verkeerde posities

Direct antwoord: Zorg ervoor dat je het juiste coördinatensysteem gebruikt (origine in de linksonderhoek) en dat de paginarotatie‑metadata wordt gerespecteerd. Pas de Box‑waarden dienovereenkomstig aan.
Oplossing:

// 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;
}

Probleem 3 – Geheugenproblemen met grote documenten

Direct antwoord: Verwerk grote PDF’s in batches, disposeer de Annotator na elke batch, en schakel streaming‑modus in om te voorkomen dat het volledige bestand in RAM wordt geladen.
Oplossing:

// 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();
        }
    }
}

Tips voor prestatie‑optimalisatie

Hoe kan ik duizenden PDF’s efficiënt batch‑verwerken?

Verzamel annotatie‑verzoeken in een lijst, open één Annotator per document, pas alle wijzigingen toe, en roep vervolgens één keer Save() aan. Dit vermindert I/O‑overhead, maakt gebruik van interne buffering, en houdt het geheugenverbruik voorspelbaar bij grote workloads.
Verzamel annotatie‑verzoeken in een lijst, open één Annotator per document, pas alle wijzigingen toe, en roep vervolgens één keer Save() aan. Dit vermindert I/O‑overhead en maakt gebruik van interne buffering.

// 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

Hoe beheer ik het geheugen bij het werken met PDF’s met honderden pagina’s?

Schakel de LoadOptions‑vlag MemoryOptimization = true in en verwerk pagina’s opeenvolgend. Dit vertelt de bibliotheek om alleen de actieve pagina in het geheugen te houden, waardoor de RAM‑voetafdruk voor zeer grote bestanden drastisch wordt verlaagd.

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

Hoe moet ik vaak geraadpleegde documenten cachen?

Sla de geserialiseerde annotatie‑JSON op in een gedistribueerde cache (bijv. Redis) met de document‑ID als sleutel. Wanneer een gebruiker dezelfde PDF aanvraagt, haal je de gecachte annotatieset op in plaats van het bestand opnieuw van schijf te lezen, waardoor latentie en I/O‑belasting worden verminderd.

// 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];
}

Best practices voor productie‑applicaties

Hoe implementeer ik robuuste foutafhandeling en logging?

Omhul elke Annotator‑operatie met try‑catch‑blokken, log uitzonderingen met een gestructureerde logger (Serilog, NLog), en voeg het documentpad, gebruikers‑ID en stack‑trace toe. Dit maakt foutopsporing veel eenvoudiger in productie en helpt je te voldoen aan audit‑vereisten voor compliance.

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;
    }
}

Hoe kan ik door gebruikers geleverde annotatiedata valideren?

Controleer dat binnenkomende JSON‑velden (paginanummer, rechthoekcoördinaten, annotatietype) binnen acceptabele bereiken vallen voordat je de annotatie‑objecten maakt. Weiger out‑of‑bounds coördinaten met een duidelijke HTTP 400‑respons en geef een nuttige foutmelding.

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;
}

Hoe zorg ik voor thread‑veiligheid in een multi‑user webservice?

Instantieer een nieuwe Annotator per verzoek; deel nooit één instantie over threads. Als je toegang tot een gedeeld bestand moet coördineren, gebruik dan een SemaphoreSlim of een bestands‑niveau lock om gelijktijdige writes te voorkomen.

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);
        }
    }
}

Wanneer GroupDocs.Annotation te gebruiken versus alternatieven

Kies GroupDocs.Annotation wanneer je nodig hebt:

  • Cross‑format ondersteuning (PDF, DOCX, PPTX, afbeeldingen).
  • Geavanceerde annotatietypen zoals redactie, vrije‑hand tekeningen, en aangepaste metadata.
  • Enterprise‑grade licenties, SLA‑ondersteuning, en regelmatige beveiligingsupdates.

Overweeg lichtere alternatieven wanneer je alleen met PDF’s werkt, strikte budgetbeperkingen hebt, of een open‑source stack vereist.

Veelgestelde vragen

V: Kan ik GroupDocs.Annotation .NET gebruiken zonder licentie?
Ja, de gratis proefversie biedt volledige functionaliteit voor 30 dagen maar voegt evaluatiewatermerken toe aan elk uitvoerbestand. Voor elke productie‑implementatie moet je een tijdelijke of volledige licentie toepassen om die watermerken te verwijderen.

V: Welke .NET‑versies worden ondersteund door GroupDocs.Annotation?
De bibliotheek werkt met .NET Framework 4.6.1+, .NET Core 2.0+, .NET 5, .NET 6, en .NET 7, waardoor hij geschikt is voor zowel legacy Windows‑services als moderne cross‑platform containers.

V: Hoeveel kost GroupDocs.Annotation .NET?
De prijs begint rond $1.999 voor een ontwikkelaarslicentie en schaalt met het aantal geïmplementeerde applicaties. Bekijk de GroupDocs pricing page voor de laatste tarieven en volumekortingen.

V: Welke documentformaten kan ik annoteren met GroupDocs.Annotation?
Meer dan 50 formaten worden ondersteund, waaronder PDF, DOC/DOCX, PPT/PPTX, XLS/XLSX, JPEG, PNG, TIFF, en nog veel meer. PDF krijgt de meest uitgebreide functionaliteit, inclusief vector‑gebaseerde vormen en OCR‑klare redactie.

V: Kan ik wachtwoord‑beveiligde PDF’s annoteren?
Ja. Geef het wachtwoord op bij het construeren van de Annotator:

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

V: Waarom verschijnen mijn annotaties op de verkeerde positie?
GroupDocs gebruikt een cartesiaans coördinatensysteem waarbij (0,0) de linksonderhoek is en metingen in punten zijn. Onjuiste positionering ontstaat meestal door pixel‑gebaseerde waarden te gebruiken of de paginarotatie te negeren. Converteer pixelwaarden naar punten (1 pixel ≈ 0.75 punt bij 96 DPI) en pas aan voor eventuele rotatiemetadata.

// 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;
}

V: Hoe haal ik bestaande annotaties op uit een PDF?
Roep de Get()‑methode aan op de Annotator‑instantie; deze retourneert een collectie van alle annotatie‑objecten met hun ID’s, types en metadata.

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

V: Kan ik specifieke annotaties programmatisch verwijderen?
Ja. Gebruik Delete(id) om een enkele annotatie te verwijderen of DeleteAll() om het document volledig te wissen. Je kunt ook filteren op type vóór het verwijderen.

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

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

V: Hoe werk ik annotatie‑eigenschappen bij, zoals kleur of bericht?
Haal de annotatie op, wijzig Color of Message, en roep Update() aan. De wijziging wordt bij de volgende Save()‑call opgeslagen.

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

V: Kan ik aangepaste metadata toevoegen aan annotaties?
Absoluut. De meeste annotatieklassen bieden een Replies‑collectie waar je sleutel‑waardeparen kunt opslaan, waardoor je reviewer‑ID’s, tijdstempels of workflow‑statussen kunt koppelen.

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

V: Ondersteunt GroupDocs.Annotation digitale handtekeningen op geannoteerde PDF’s?
Hoewel de Annotation‑bibliotheek zich richt op markup, kun je deze combineren met GroupDocs.Signature .NET om cryptografische handtekeningen toe te passen na het toevoegen van annotaties, waardoor zowel visuele als juridische integriteit wordt gegarandeerd.

V: Kan ik annotaties exporteren naar JSON of XML voor externe verwerking?
De bibliotheek bevat geen ingebouwde exporter, maar je kunt de annotatie‑objecten zelf serialiseren met System.Text.Json of XmlSerializer. Dit maakt integratie met externe auditsystemen eenvoudig.

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

Laatst bijgewerkt: 2026-05-21
Getest met: GroupDocs.Annotation 23.12 voor .NET
Auteur: GroupDocs

Gerelateerde tutorials