Viewer är tillståndslös — av design

Viewer behåller inte någon per‑request dokumentdata. Det är en sealed class, den implementerar aldrig IDisposable, och varje dokument du öppnar lever i en separat session som ramverkets cache hanterar. På grund av detta kan du injicera en enda Viewer‑instans var som helst i din ASP.NET Core‑app och säkert anropa den från många samtidiga förfrågningar.

---

Konsekvenser av en tillståndslös tjänst

• Inga dolda resurser – tjänsten själv allokerar aldrig stora buffertar som kräver explicit rensning.
• Trådsäker som standard – eftersom ingen request‑specifik state lagras, kan samma Viewer‑instans användas av flera trådar utan låsning.
• Skalbara distributioner – horisontell skalning fungerar direkt; du behöver inga sticky sessions eller serveraffinitet, bara sessionstoken som klienten har.

All dokument‑specifik information (sidor, annotationer, sökindex) hålls i en session skapad av OpenDocumentAsync. Sessionen lagras i IMemoryCache (eller någon annan IDistributedCache du konfigurerar) och löper automatiskt ut efter en period av inaktivitet (standard 60 minuter). När du är klar kan du anropa CloseDocument för att frigöra cache‑posten tidigt.

Registrering av den tillståndslösa Viewer

Eftersom Viewer saknar muterbart tillstånd, registrera den en gång under uppstart:

builder.Services.AddDoconut();               // registrerar Viewer och nödvändig middleware
builder.Services.AddSession();               // krävs för token-säkerhet
builder.Services.AddDistributedMemoryCache(); // enkel cache för demon

Anropet AddDoconut kopplar också in middleware som levererar Viewerns statiska resurser. När tjänsterna är på plats kan du begära Viewer i vilken endpoint‑signatur som helst.

Minimal öppna‑dokument‑endpoint (net‑8‑exempel)

Följande kod är exakt utdraget från den officiella dokumentationen och fungerar direkt i ett .NET 8 minimal‑API‑projekt:

app.MapPost("/api/open", async (string fileName, Viewer viewer) =>
{
    var token = await viewer.OpenDocumentAsync($"files/{fileName}");
    return Results.Content(token, "text/plain");
});

Vad koden gör

1. Accepterar ett filnamn – klienten talar om för servern vilken fil under wwwroot/files som ska öppnas.
2. Anropar OpenDocumentAsync – den tillståndslösa Viewer skapar en ny session, lagrar den i cachen och returnerar en opak token.
3. Returnerar token som ren text – klienten får bara token; servern skickar aldrig dokumentets bytes i detta svar.

Eftersom Viewer inte innehåller någon dokumentdata, behöver endpointen inga using‑block, Dispose‑anrop eller per‑request‑fabriker. Token är den enda autentiseringsuppgiften som klienten någonsin kommer att skicka tillbaka till viewer‑widgeten (objViewer.View(token) på front‑end).

Använda token på klientsidan

När token har returnerats, anropar front‑end‑widgeten objViewer.View(token). Widgeten inkluderar sedan samma token i varje efterföljande förfrågan för sidbilder, sökningar eller annoteringsåtgärder. Servern validerar token mot den session som ursprungligen öppnade dokumentet. Om token presenteras från en annan browsersession, returnerar viewer ett auktoriseringsfel, vilket är det avsedda säkerhetsbeteendet.

Stänga en session tidigt (valfritt)

Om ditt arbetsflöde vet att ett dokument aldrig kommer att nås igen, kan du frigöra cache‑posten genom att anropa CloseDocument på Viewer. Detta tar bort sessionen från cachen och förhindrar att sliding‑expiration‑timern håller den vid liv.

Sammanfattning av den tillståndslösa flödet

Steg	Vad händer	Var state lagras
Injicera Viewer	En enda Viewer‑instans skapas vid uppstart.	I DI‑behållaren (singleton).
OpenDocumentAsync	Licens kontrollerad → session skapad → token returnerad.	Session lagrad i IMemoryCache (eller distribuerad cache).
Klienten renderar	Widgeten skickar token med varje förfrågan.	Token är den enda per‑dokument‑data som klienten har.
Sessionens utgång / CloseDocument	Cache‑posten tas bort efter timeout eller explicit stängning.	Inga kvarvarande resurser i Viewer‑tjänsten.

Eftersom tjänsten själv aldrig lagrar dokumentdata, kan du säkert skala ut din webbfarm, ersätta noder eller starta om applikationen utan att förlora någon användarsynlig state—endast token blir ogiltig, vilket får klienten att öppna dokumentet igen.

Distribuera den tillståndslösa Viewer i din app

1. Lägg till AddDoconut, AddSession och en cache‑leverantör till Program.cs.
2. Klistra in öppna‑endpoint‑snutten i din minimal‑API‑konfiguration.
3. Skicka den returnerade token till objViewer.View(token) på front‑end.

Du har nu ett helt tillståndslöst, produktionsklart dokument‑öppnings‑API som utnyttjar Doconut’s Viewer‑design.