GroupDocs.Annotation is UI-agnostisch. Het leest en schrijft markup in documenten en tekent niets op een scherm. Voor een serverbibliotheek is dat de juiste scheiding — en het laat één vraag over voor iedereen die het adopteert: hoe tekent iemand eigenlijk de annotatie?
De gebruikelijke antwoorden zijn zwaar: een commerciële viewer insluiten, of de Angular‑demo adopteren en vervolgens proberen uit te breiden. Er is een lichtere oplossing. Pagina‑afbeeldingen, een canvas en zes eindpunten — geen viewer‑component, geen front‑end framework, geen build‑stap, geen CDN. Het draait bovendien zonder enige uitgaande netwerktoegang, wat nu belangrijker is dan voorheen.
Het voorbeeld staat op GitHub:
browser-annotation-ui-net — dotnet run en sleep een vakje op de pagina.
Het idee in één alinea
Render elke pagina één keer als een PNG zonder annotaties en cache deze. Stuur de annotatielijst naar de browser als data. Het canvas tekent de markup bovenop de afbeelding. Een opmerking toevoegen is dan een kleine schrijf‑operatie naar het document plus een herladen van de lijst — geen her‑renderen van de pagina — en de markup blijft selecteerbaar, klikbaar en beantwoordbaar in plaats van in een afbeelding te worden gebakken.
De eindpunten
| Methode | Route | Doel |
|---|---|---|
GET |
/api/documents/{name}/info |
paginacount en de grootte van elke pagina, in points |
GET |
/api/documents/{name}/pages/{n}/image |
PNG van pagina n |
GET |
/api/documents/{name}/annotations |
elke annotatie als één rechthoek in paginaverdeling |
POST |
/api/documents/{name}/annotations |
voeg er één toe |
PUT |
/api/documents/{name}/annotations/{id} |
wijzig het bericht of voeg een antwoord toe |
DELETE |
/api/documents/{name}/annotations/{id} |
verwijder er één |
Elke schrijf‑operatie retourneert de volledige lijst, zodat de browser nooit hoeft te redeneren over wat de server nu bevat.
Rendering
PreviewOptions previewOptions = new(page => File.Create(CachePath(name, page)))
{
PreviewFormat = PreviewFormats.PNG,
PageNumbers = new[] { pageNumber }, // 1-based
RenderAnnotations = false, // het canvas tekent de markup
Resolution = 144
};
annotator.Document.GeneratePreview(previewOptions);
Vergelijk de tijdstempel van de gecachte afbeelding met die van het document en render alleen opnieuw wanneer het document daadwerkelijk is gewijzigd.
Pixels in, paginabereiken uit
Het canvas houdt zijn rechthoek in afbeeldingspixels en stuurt de grootte van de afbeelding waarop het getekend heeft — niet een schaalfactor:
body: JSON.stringify({
page: currentPage,
x, y, width, height,
imageWidth: img.clientWidth,
imageHeight: img.clientHeight,
message: window.prompt('Comment'),
user: 'Reviewer'
})
Die ene beslissing houdt de UI correct wanneer de preview‑resolutie verandert, wanneer CSS de afbeelding schaalt, of wanneer iemand het op een telefoon opent. De server doet de rekenkunde:
double scaleX = page.Width / request.ImageWidth;
double scaleY = page.Height / request.ImageHeight;
annotator.Add(new AreaAnnotation
{
PageNumber = page.PageNumber - 1, // PageInfo is 1-based, annotations are 0-based
Box = new Rectangle(
(float)(request.X * scaleX), (float)(request.Y * scaleY),
(float)(request.Width * scaleX), (float)(request.Height * scaleY)),
BackgroundColor = 0xFFE699,
PenColor = 0xE08C00,
Opacity = 0.35,
Message = request.Message,
User = new User { Id = 1, Name = request.User, Role = Role.Editor }
});
AreaAnnotation.Box wordt gemeten vanaf de linkerbovenhoek van de pagina — dezelfde richting waarin de browser meet — zodat een getekende doos met een schaal wordt overgebracht zonder omkering.
Stuur één vorm van rechthoek naar de browser
Tekst‑markup deelt die oorsprong niet. HighlightAnnotation.Points en verwante waarden worden gemeten vanaf de linkeronderhoek. Converteer op de server, zodat de front‑end alleen linkerboven‑dozen ziet:
x = minX;
y = page.Height - maxY; // omkeren naar linkerboven
width = maxX - minX;
height = maxY - minY;
Doe dit en een markering die in Word, in Acrobat, of door een geautomatiseerde beoordelingsronde is toegevoegd, verschijnt op de juiste plek in uw UI zonder dat de JavaScript iets weet van PDF‑geometrie.
Schrijft swap‑bestanden
De annotator houdt de bron open en kan niet overschrijven terwijl het bestand wordt gelezen:
using (Annotator annotator = new Annotator(path))
{
annotator.Add(annotation);
annotator.Save(path + ".tmp");
}
File.Move(path + ".tmp", path, overwrite: true);
InvalidatePreviewCache(name);
Neem een per‑document lock rond de hele reeks. Twee verzoeken die tegelijk lezen, wijzigen en hetzelfde bestand herschrijven, zullen één van de wijzigingen verliezen.
Wat dit ontwerp niet oplost
Het is het waard om dit duidelijk te zeggen, want het bepaalt of u het in de huidige vorm kunt leveren:
- Annotation ids change after a write. Ze worden toegewezen terwijl het document wordt gelezen, niet in het document opgeslagen. Een UI die de lijst na elke wijziging herlaadt is prima. Een multi‑user systeem moet annotaties in een eigen tabel bewaren en import‑ en export‑functionaliteit gebruiken om ze in en uit het bestand te verplaatsen — wat ook de manier is om een audit‑trail en per‑user zichtbaarheid te krijgen.
- The whole document is rewritten on every change. Acceptabel voor een contract van 30 pagina’s, ongeschikt voor een archief van 2 000 pagina’s.
- There is no authentication. Elke aanroeper in het voorbeeld is “Reviewer”.
Uitvoeren
git clone https://github.com/groupdocs-annotation/browser-annotation-ui-net.git
cd browser-annotation-ui-net
dotnet run --project src/AnnotationUi
Of in een container, met --network none als u wilt zien dat het werkt zonder enige uitgaande verbinding:
docker build -t annotation-ui .
docker run --rm -p 8080:8080 annotation-ui
De stap‑voor‑stap versie staat in de documentatie:
Bouw een annotatie‑UI voor uw webapp.
Als u al een JavaScript PDF‑viewer hebt ingebed, houd die dan voor weergave en gebruik alleen deze eindpunten voor opslag — geen van de geometrieregels verandert.