Plugin-system

Doconuts kärna förblir slank; valfri funktionalitet levereras som plugins — separata NuGet-paket som bidrar med visare eller tjänster och slås på av din licens. Den här sidan förklarar registreringsmodellen, hur licensgating fungerar vid körning, och hur du ansluter din egen visare.

Registrering av en plugin

Varje plugin-paket exponerar en plugin-klass. Du registrerar den en gång, vid start:

builder.Services.AddDoconut(options =>
{
    options.AddPlugin<Doconut.Plugins.Converter.ConverterPlugin>();
    options.AddPlugin<Doconut.Plugins.Dicom.DicomPlugin>();
});

AddPlugin<TPlugin>() instansierar pluginen och anropar dess Register‑återuppringning mot pluginregistret som hålls på DoconutOptions. Allt som en plugin bidrar med märks med pluginens required capability. AddDoconut() validerar registrerade plugins omedelbart: en saknad licens, gammal TRIAL‑fil eller betald licens utan kapaciteten får start misslyckas med InvalidOperationException. En Temporary/Demo-registrering behålls över utgången, men dess körningskapaciteter återkallas efter utgångsdatumet.

Kontraktet

En plugin implementerar ett avsiktligt litet gränssnitt:

public interface IDoconutPlugin
{
    string Name { get; }                          // t.ex. "Doconut DICOM Viewer"
    LicenseCapability RequiredCapability { get; } // licensgrind
    void Register(IDoconutPluginBuilder builder); // bidra med visare/tjänster
}

Inuti Register accepterar byggaren två typer av bidrag:

• builder.RegisterViewer(".dcm", () => new DicomViewer()) — en visare för en filändelse,
• builder.RegisterService<TContract>(() => …) — en typad tjänst som andra delar av pipelinen kan slå upp.

Kapaciteter och styrning

Kapaciteter är licensenheterna. Converter och Dicom levereras som opt‑in plugins; Search och Annotation är inbyggda funktioner som styrs på samma sätt. Basvisaren är inte en kapacitet — den är förutsättningen, exponerad som IsViewerLicensed på licenstjänsten.

Startvalidering förhindrar normalt en olicensierad plugin från att komma in i begäranpipelines. Visarfabriken tillämpar också två defensiva körningsregler, vilka är viktiga om rättigheter ändras efter start:

• Plugin åsidosätter en inbyggd visare (en plugin påstår en filändelse som den inbyggda registret också hanterar): med den licensierade kapaciteten vinner plugin‑visaren; utan den, Doconut faller tyst tillbaka till den inbyggda visaren. Användare ser fortfarande sitt dokument — de får bara inte plugin‑funktionen.
• Endast plugin-format (t.ex. .dcm — DICOM har ingen inbyggd visare): utan kapaciteten misslyckas öppningsanropet hårt:

LicenseException: This document type requires the 'Dicom' plugin license.

En aktiv Temporary-licens ger alla kapaciteter (med ren, ovattenmärkt basvisning). Detta är en klassisk källa till överraskningar vid driftsättning: att registrera samma plugins med en köpt licens som utelämnar en av deras kapaciteter får AddDoconut() att misslyckas under start. Jämför IsCapabilityGranted(...) med din plan innan du distribuerar. Det motsatta: med ingen licens alls, inget beviljas — en saknad licens är inte en Temporary-licens.

Samma gating visas på klientsidan: Viewer.ReferenceScripts() och ReferenceCss() emitterar script-/style‑paketen för de licensstyrda funktionerna (sökning, annotation, …) endast när licensen aktiverar dem, så widgetens UI förblir konsekvent med vad servern faktiskt gör.

Funktion- och plugin‑karta

Produkt‑UI använder “plugin” som en bred funktionsetikett, men serverregistreringen skiljer sig:

Annotation och vanlig Search använder inte AddPlugin<TPlugin>(); deras paket emitteras endast när licensen beviljar motsvarande kapacitet. Konverterare och DICOM är de släppta opt‑in IDoconutPlugin‑implementationerna för detta dokumentationspaket.

De godkända .NET 6‑artefakterna innehåller Doconut.NET6.Converter och Doconut.NET6.Dicom i samma version som kärnpaketet.

Släppta plugin‑paket

Var och en har en dedikerad sida under Plugins med sin konfiguration och användning.

Anpassade visare — din egen format‑hanterare

Du kan ansluta en visare till pipelinen utan att skriva ett plugin‑paket, direkt från Program.cs:

builder.Services.AddDoconut(options =>
{
    options.RegisterViewer(
        ".myext",
        () => new MyCustomViewer(),               // implementerar IFormatViewer
        () => new ImageConfig { ImageResolution = 150 }); // valfri standardkonfiguration
});

Anpassade visare har företräde framför allt — både inbyggda och plugins — och är inte licensstyrda (de är din kod). Fabriken faller tillbaka till en ImageConfig när du inte tillhandahåller en standardkonfiguration.

Viktiga punkter

• Plugins registreras explicit och deras LicenseCapability valideras under AddDoconut() — saknad eller otillräcklig icke‑tillfällig rättighet misslyckas snabbt.
• Override‑stil plugins degraderas smidigt; endast plugin‑format misslyckas med en LicenseException.
• En aktiv Temporary‑licens låser upp allt; produktion låser upp det du köpt. Verifiera med IDoconutLicenseService innan leverans.