Konverteringsplugin

Konvertera dokument till 45 målformat

Converter‑pluginet gör Doconut till en dokumentkonverteringstjänst. Det bidrar med motorn bakom det offentliga DocumentConverter‑gränssnittet och — vid val — en inbyggd widget som levereras av DocImage.axd, så att du kan konvertera dokument från C#, från widgeten eller från ett frontend du själv skriver.

YtaNär du ska använda den
DocumentConverter (C#)Du konverterar på servern, utan någon webbläsare inblandad
Inbyggd widget (doconutConverter.js)Du vill ha en färdig uppladdnings-, konverterings- och nedladdningsskärm i din sida
HTTP‑endpoints på DocImage.axd (?convert=open|run|download)Du bygger ditt eget konverterings‑UI mot ett dokumenterat serverkontrakt

Installera paketet

powershell
Install-Package Doconut.NETFramework.Converter

För att låsa pluginet till den version som den här dokumentationen beskriver:

powershell
Install-Package Doconut.NETFramework.Converter -Version 26.10.0

Behåll Converter‑paketet på samma version som Doconut.NETFramework.

Pluginens licensfil, Doconut.Viewer.Converter.lic, placeras i samma mapp som Doconut.Viewer.lic; den läses tillsammans med visningslicensen.

Registrera pluginet

Varje plugin registreras på samma sätt: AddPlugin<TPlugin>() i DoconutHost.Initialize, anropad från Application_Start.

csharp
Doconut.DoconutHost.Initialize(options =>
{
    options.LicensePath = HostingEnvironment.MapPath("~/wwwroot/Doconut.Viewer.lic");
    options.AddPlugin<Doconut.Plugins.Converter.ConverterPlugin>();
});

Det är allt som C#‑gränssnittet behöver. Widgeten och dess HTTP‑endpoints är ett separat val, AddConverterWidget() (se Inbyggd widget).

Pluginet behöver en licens som ger Converter‑kapaciteten. Utan en sådan kastar DoconutHost.Initialize från Application_Start:

text
The Converter plugin is registered via AddPlugin but no active license grants Converter. Remove the AddPlugin<...>() call or install a license (or trial/demo) that includes Converter.

I System.Web betyder det att varje begäran svarar med en tom 500, och orsaken finns bara i Windows‑händelseloggen (källa ASP.NET). Det kastas för ingen licens, en äldre TRIAL‑fil, en licens utan Converter, och en betald licens som används utanför dess versionsfönster. Tillfälliga Demo/NFR‑licenser accepteras. Se Licensinställning.

Licensiering & vattenstämpel

LicensstatusUppstartKonverteringsresultat
Betald visningslicens som ger Converter, inom dess versionsfönsterStartarRen — watermarked: false
Aktiv tillfällig (Demo/NFR) licensStartarKonverterar, med utvärderingsvattenstämpeln — watermarked: true
Utgången tillfällig (Demo/NFR) licensStartarKonverterar, med utvärderingsvattenstämpeln — watermarked: true
Ingen licens, en äldre TRIAL‑fil, en licens utan Converter, eller en betald licens utanför dess versionsfönsterApplication_Start kastar; varje begäran svarar med en tom 500—

Det DocumentConverter‑gränssnittet och widgetens ?convert=run‑hanterare tillämpar samma regel. En integration kan byggas och testas end‑to‑end på en utvärderingslicens innan köp — endast utdata‑bytena förändras.

En DICOM‑källa (.dcm, .ima) kräver också Dicom‑kapaciteten. Utan den kastar ConvertAsync en LicenseException (Converting '.dcm' requires the Dicom capability license.) och widgetens open svarar 403.

Användning från C#

Varje konvertering returnerar en sökbar MemoryStream placerad på 0. DocumentConverter är stateless: hämta den från DoconutHost.Services där du än behöver den och återanvänd den fritt.

csharp
// Lös upp DocumentConverter från DoconutHost.Services; dess konstruktor är intern, så aldrig `new` den.
Stream pdf = await converter.ConvertAsync("contract.docx", ConversionTarget.Pdf, ct: ct);
csharp
// sourceExtension inkluderar den inledande punkten. password är null om inte dokumentet är skyddat.
Stream png = await converter.ConvertAsync(stream, ".xlsx", ConversionTarget.Png, password: null, ct: ct);
csharp
Stream html = await converter.WordToHtmlAsync("report.docx", ct);
csharp
// html: ett Stream som innehåller HTML för att omvandla tillbaka till ett Word-dokument, till exempel resultatet av WordToHtmlAsync.
Stream docx = await converter.HtmlToWordAsync(html, ConversionTarget.Docx, ct);

Två detaljer som är lätta att missförstå: sourceExtension på stream‑överladdningen måste inkludera den inledande punkten (".xlsx", inte "xlsx"), annars löser den sig inte. Och trots sitt namn returnerar WordToHtmlAsync Task<Stream>, inte Task<string> — HTML‑dokumentet (bilder inbäddade som Base64) levereras som en stream, precis som alla andra resultat.

Anroparen äger den MemoryStream som en konvertering returnerar och bör avyttra den efter kopiering eller återlämnande (MVC:s File(stream, …) avyttrar den åt dig). Konstruera eller avyttra inte DocumentConverter själv — dess konstruktor är intern.

I en MVC 5‑controller

Gör åtgärden asynkron och await konverteringen:

csharp
[HttpPost]
public async Task<ActionResult> ToPdf(HttpPostedFileBase file)
{
    var converter = Doconut.DoconutHost.Services.GetRequiredService<DocumentConverter>();
    Stream pdf = await converter.ConvertAsync(
        file.InputStream, Path.GetExtension(file.FileName), ConversionTarget.Pdf,
        password: null, ct: Response.ClientDisconnectedToken);
    return File(pdf, "application/pdf", Path.GetFileNameWithoutExtension(file.FileName) + ".pdf");
}

I Web Forms: blockera aldrig en konvertering

En Web Forms‑sida körs i ett enkeltrådat begärankontext. ConvertAsync återupptas i den kontexten när den är klar, så en sida som väntar på den synkront — .Result, .Wait(), .GetAwaiter().GetResult() — håller fast den tråd som konverteringen behöver för att slutföras. Begäran återvänder aldrig. Webbläsaren snurrar vidare, IIS loggar ingenting, och resten av webbplatsen fortsätter fungera, så det ser ut som en långsam konvertering snarare än en dödlås.

Markera sidan Async="true" och kör konverteringen som en asynkron siduppgift:

aspx
<%@ Page Language="C#" Async="true" CodeBehind="Convert.aspx.cs" Inherits="MyApp.Convert" %>
csharp
// Web Forms: @Page-direktivet behöver Async="true", och konverteringen körs som en asynkron siduppgift.
// Att blockera på den istället (.Result, .Wait(), .GetAwaiter().GetResult()) deadlockar begäran:
// den returnerar aldrig, och inget loggas.
protected void Page_Load(object sender, EventArgs e)
{
    if (!IsPostBack) return;

    RegisterAsyncTask(new PageAsyncTask(async ct =>
    {
        var converter = Doconut.DoconutHost.Services.GetRequiredService<DocumentConverter>();

        using (var pdf = await converter.ConvertAsync(
                   Server.MapPath("~/App_Data/contract.docx"), ConversionTarget.Pdf, ct: ct))
        using (var ms = new MemoryStream())
        {
            if (pdf.CanSeek) pdf.Position = 0;
            await pdf.CopyToAsync(ms);

            Response.ContentType = "application/pdf";
            Response.AddHeader("Content-Disposition", "attachment; filename=contract.pdf");
            Response.BinaryWrite(ms.ToArray());
            // Context, inte HttpContext.Current: efter en await kan den senare vara null.
            Context.ApplicationInstance.CompleteRequest();
        }
    }));
}

Utan Async="true" i @Page‑direktivet ignoreras RegisterAsyncTask tyst. Efter en await, använd sidans Context; HttpContext.Current kan vara null där.

Målförformat

ConversionTarget (namnrymd Doconut.Configs.Conversion) har 45 medlemmar:

text
Pdf, Docx, Doc, Html, Xlsx, Pptx, Png, Jpeg, Csv, Tiff, Bmp, Gif, Svg, Xml,
Txt, Xls, Jp2, Rtf, Odt, Ods, Odp, Epub, Xps, Webp, Msg, Eml, Emlx, Mhtml,
Xlsm, Xlsb, Ppt, Docm, Dot, Dotx, Dotm, Vsdx, Vssx, Vstx, Vsdm, Vssm, Vstm,
Vdx, Vsx, Vtx, Ico

Inte varje källa konverteras till varje mål: varje källas formatfamilj (Word, Excel, PowerPoint, PDF, CAD, Bild, E‑post, Diagram, Projekt, PSD, webb‑dokument, DICOM) har sin egen uppsättning tillåtna mål. Att konvertera en DICOM‑källa (.dcm, .ima) kräver också en licens som ger Dicom‑kapaciteten; dess mål är Pdf, Png, Jpeg, Bmp, Tiff och Gif. Hardkoda inte den här uppräkningen som ditt UI:s mållista: ?convert=open returnerar allowedTargets för den uppladdade filen, och det är vad som bör styra en väljare.

Inbäddningswidget

Aktivera slutpunkterna

Widgetens ?convert=open|run|download‑slutpunkter levereras av DocImage.axd och är avstängda som standard. Aktivera dem bredvid plugin‑registreringen:

csharp
Doconut.DoconutHost.Initialize(options =>
{
    options.LicensePath = HostingEnvironment.MapPath("~/wwwroot/Doconut.Viewer.lic");
    options.AddPlugin<Doconut.Plugins.Converter.ConverterPlugin>();
    options.AddConverterWidget(widget =>
    {
        widget.MaxUploadMb = 25;
    });
});
// System.Web läser hela uppladdningen innan Doconut ser den: behåll maxRequestLength (KB) och
// maxAllowedContentLength (bytes) i Web.config ovanför widgetens MaxUploadMb.

AddConverterWidget() utan argument aktiverar widgeten med standardvärdena (MaxUploadMb = 25). Den ger inte konverteringsrättigheter i sig: den behöver AddPlugin<ConverterPlugin>(), annars kastar DoconutHost.Initialize:

text
AddConverterWidget() was called but the Converter plugin is not registered. Add options.AddPlugin<Doconut.Plugins.Converter.ConverterPlugin>() (the widget needs it), or remove the AddConverterWidget() call.

Två saker att kontrollera när widgeten beter sig fel:

  • basePath: '/DocImage.axd'. Widgetens standard, /doconut, är ASP.NET Core‑slutpunkten. I detta paket är slutpunkterna DocImage.axd‑hanteraren från Web.config.
  • Skriptet och slutpunkterna är oberoende. Resursmodulen levererar doconutConverter.js oavsett om widgeten är aktiverad eller inte. Utan AddConverterWidget() laddas widgeten, målar sin drozzon och ser helt korrekt ut — och dess första åtgärd svarar 404.

Uppladdningsgränser

ASP.NET läser hela begärans kropp innan DocImage.axd körs. En uppladdning över MaxUploadMb men under värdens gränser får widgetens egna JSON 413 (File is too large.). En uppladdning över värdens gränser avvisas först av IIS, med en felsida som widgeten inte kan läsa. Behåll båda värdens gränser i Web.config över widgetens tak:

xml
<system.web>
  <httpRuntime maxRequestLength="30720" />           <!-- KILOBYTES: 30 MB -->
</system.web>
<system.webServer>
  <security>
    <requestFiltering>
      <requestLimits maxAllowedContentLength="31457280" />  <!-- BYTES: 30 MB -->
    </requestFiltering>
  </security>
</system.webServer>

Bädda in den

html
<div id="doconut-convert"></div>
<script src="/doconut-res/js/doconutConverter.js"></script>
<script>
  Doconut.convert('#doconut-convert', { basePath: '/DocImage.axd', maxUploadMb: 25 });
</script>

Doconut.convert(selectorOrElement, options) tar en CSS-selektor eller ett element, kastar ett fel om monteringen inte hittas, och returnerar ett handtag. Widgeten laddar upp en fil, visar en förhandsgranskning av sida 1, låter användaren välja en av allowedTargets, konverterar, förhandsgranskar resultatet när det kan, och erbjuder nedladdning.

Alternativ

AlternativTypStandardAnteckningar
basePathstring/doconutEndpoint‑URL:en. Ställ in '/DocImage.axd' på detta paket
resPathstring/doconut-resAccepterad för konsistens med andra Doconut‑widgetar; konverteringswidgeten bygger ingen URL från den
maxUploadMbnumber25Endast förhandskontroll på klienten; servern upprätthåller sin egen gräns
licenseUrlstring | nullnullGör vattenstämpelmeddelandet på resultatskärmen till en länk
labelsobject{}Åsidosätter någon delmängd av widgetens engelska strängar

Återuppringningar

ÅteruppringningUtlöses närInnehåll
onReady()Widgeten har renderat sin droppskärm—
onSourceLoaded({ token, pages, sourceExt, allowedTargets })?convert=open lyckasKälltoken, sidantal, källa‑filändelse (utan inledande punkt), tillåtna mål
onConverted({ downloadToken, resultToken, resultPages, downloadName, watermarked, target })?convert=run lyckasKörningssvaret plus den begärda target
onDownload({ downloadName, downloadToken })Användaren klickar på DownloadUtlöses parallellt med webbläsarens egen nedladdning
onError({ phase, message })En öppnings‑ eller körningsbegäran misslyckasphase är 'open' eller 'run'; message är det sanerade serverfelet

En återuppringning som kastar ett fel fångas och loggas; den bryter aldrig widgetens flöde.

Imperativt handtag

Doconut.convert() returnerar widget‑instansen:

javascript
const conv = Doconut.convert('#doconut-convert', { basePath: '/DocImage.axd' });
const file = document.querySelector('#picker').files[0]; // a File from your own <input type="file" id="picker">
conv.reset();         // tillbaka till droppskärmen; avfyras inte igen onReady
conv.loadFile(file);  // startar flödet med en File; no-op om inte widgeten är på sin droppskärm
conv.destroy();       // tar bort lyssnare, tömmer mount; instansen är oanvändbar efter detta

Etiketter

Varje sträng har en engelsk standard; labels åsidosätter någon delmängd och resten förblir engelska. Fragment som ändras vid körning använder {placeholders}, såsom uploading: 'Uploading {name}…' och pages: '{n} pages'.

NyckelEngelsk standard
dropPromptDrag & drop a document here
dropHintPDF, Word, Excel, PowerPoint, images and more
chooseFileChoose file
uploadingUploading {name}…
page / pages1 page / {n} pages
noTargetsNo conversion targets are available for this file.
convertTo / convertConvert to / Convert
convertingConverting to {target}…
readyToDownloadReady to download
download / convertAnotherDownload / Convert another
watermarkNoticeOutput is watermarked — get a license to remove it.
retryRetry
genericErrorSomething went wrong. Please try again.
sizeLimitThat file is larger than the {mb} MB upload limit. Please choose a smaller file.
serverErrorThe server could not process this request. Please try again.
networkErrorCould not reach the server. Please check your connection and try again.

Ytterligare nycklar täcker drop‑zonens aria-label (dropAriaLabel), förhandsgranskningsalt‑texterna (previewAlt, resultAlt), den länkade formen av vattenstämpelmeddelandet som används med licenseUrl (watermarkNoticePrefix, watermarkNoticeLink, watermarkNoticeSuffix), ett oläsligt svar (badResponse) och aria-live‑meddelandena (annReady, annUploading, annLoaded, annLoadedNoTargets, annConverting, annDone, annError).

Ett JSON‑fel från servern visas exakt som servern skrev det; serverError används endast när ett misslyckat svar saknar JSON‑fel, såsom 404 för en inaktiverad widget.

Tematisering

Widgeten lägger till klassen dcw på sitt monterings‑element och läser sina färger, radie och typsnitt från CSS‑anpassade egenskaper, så att du kan tematisera den utan att röra dess interna delar:

css
#doconut-convert.dcw {
  --dcw-accent: #6b46c1;
  --dcw-radius: 12px;
  --dcw-font: "Inter", system-ui, sans-serif;
}

Standardvärden: --dcw-accent: #2b6cb0, --dcw-bg: #ffffff, --dcw-fg: #1a202c, --dcw-muted: #718096, --dcw-border: #cbd5e0, --dcw-radius: 8px, och ett system‑UI‑typsnitt för --dcw-font.

Bygg ditt eget frontend

Widgeten är en klient för detta HTTP‑kontrakt på DocImage.axd. Rutter svarar med 404 tills AddConverterWidget() anropas. Fel innehåller en JSON‑kropp, { "error": "..." }, förutom där tabellen anger "status only". Ett okänt ?convert=‑värde svarar med 400.

RuttSyfteSvar vid lyckat anrop
POST /DocImage.axd?convert=open (multipart, one file)Ladda upp och öppna ett källdokument200 — { token, pages, sourceExt, allowedTargets }
POST /DocImage.axd?token=<token>&convert=run&target=<ext>Konvertera den uppladdade källan till target200 — { downloadToken, resultToken, resultPages, downloadName, watermarked }
GET /DocImage.axd?convert=download&token=<downloadToken>Strömma den konverterade filen200 — filen, Content-Disposition: attachment, Cache-Control: no-store

sourceExt i open‑svaret har ingen inledande punkt ("docx") — motsatsen till sourceExtension‑parametern för ConvertAsync. allowedTargets listar målnamn i gemener ("pdf", "html", …); skicka en av dem som target, vilket matchas utan hänsyn till versaler/gemener. open använder den första filen i multipart‑kroppen.

resultToken är null, och resultPages är 0, när resultatet inte kan förhandsgranskas. downloadName är källfilens namn med målfilens filändelse.

Förhandsgranskningsbilderna använder den standardiserade visnings‑bild‑rutten, /DocImage.axd?token={token}&page=1&thumb=1&width={px}, med token från open eller resultToken från run. Widgeten begär width=240.

Uppladdade källor behålls i 30 minuter efter att de senast lästes; därefter svarar run med 404 och filen måste öppnas igen. downloadToken får sitt eget 30‑minutersfönster när konverteringen slutförs. resultToken är en vanlig visningstoken för att förhandsvisa resultatet; när resultatet kan förhandsgranskas är det samma värde som downloadToken.

RuttStatusNärKropp
valfri404Widgeten är inte aktiverad (AddConverterWidget() anropades aldrig)endast status
valfri405Fel verb (open/run kräver POST, download kräver GET)endast status
open400Ingen multipart‑uppladdningExpected a multipart file upload.
open400Ingen fil, eller en tom filNo file uploaded.
open400En typ som inte kan konverterasThis file type cannot be converted.
open403Filtypen kräver en funktion som licensen inte beviljar (en DICOM‑fil utan Dicom)Converting this file type requires the Dicom capability license.
open413Uppladdningen överskrider MaxUploadMb (men inte IIS‑gränserna)File is too large.
run400En felaktig token (inte ett GUID)Invalid token.
run400En target som inte kan parsas till en ConversionTargetUnknown target format.
run400Ett mål som inte finns i allowedTargetsThat target format is not available for this file.
run404Uppladdningen har gått ut eller öppnades aldrigUpload expired — please re-open the file.
open, run500Bearbetning misslyckadesEtt sanerat meddelande
download400 / 404En felaktig, okänd eller utgången nedladdningstokenendast status

En komplett rundresa med fetch:

javascript
// fil: filen att konvertera, till exempel från ett <input type="file">.
async function convertFile(file) {
  const base = '/DocImage.axd';

  // 1. open: ladda upp filen
  const form = new FormData();
  form.append('file', file, file.name);
  const openResp = await fetch(base + '?convert=open', { method: 'POST', body: form });
  if (!openResp.ok) throw new Error((await openResp.json()).error);
  const opened = await openResp.json();

  // 2. run: konvertera till PDF när det är tillåtet, annars till det första tillåtna målet
  const target = opened.allowedTargets.includes('pdf') ? 'pdf' : opened.allowedTargets[0];
  const runResp = await fetch(base + '?token=' + encodeURIComponent(opened.token) +
    '&convert=run&target=' + target, { method: 'POST' });
  if (!runResp.ok) throw new Error((await runResp.json()).error);
  const converted = await runResp.json();

  // 3. download: en enkel GET som webbläsaren kan följa
  window.location.href = base + '?convert=download&token=' + encodeURIComponent(converted.downloadToken);
}

Slutpunkterna är same-origin: den här versionen har inget CORS‑stöd. Servera ditt UI och widget‑skriptet från samma ursprung som Doconut, eller omvänd‑proxy hanteraren och resurssökvägarna under ditt UI:s ursprung.

I produktion

  1. Installera pluginet bredvid kärnpaketet, i samma version: Install-Package Doconut.NETFramework.Converter.
  2. Lägg till licensfilen. Placera Doconut.Viewer.Converter.lic i samma mapp som Doconut.Viewer.lic.
  3. Ställ in uppladdningsgränserna. MaxUploadMb i AddConverterWidget är den gräns som Doconut upprätthåller; håll maxRequestLength och maxAllowedContentLength i Web.config över den (se Uppladdningsgränser), och widgetens maxUploadMb lika med den.
  4. Blockera aldrig en konvertering i Web Forms (se I Web Forms).
  5. Disposera konverteringsresultat. Strömmen ConvertAsync returnerar är poolad; att disponera den returnerar dess buffertar till poolen.

Webbfarmar

Widgeten behåller varje uppladdning och dess resultat i minnet på servern som levererade open. Bakom en lastbalanserare utan sticky sessions kan en senare run, download eller förhandsgranskningsförfrågan nå en annan server och inte hitta uppladdningen. Registrera den delade, krypterade widgetlagringen via det andra argumentet till DoconutHost.Initialize:

csharp
byte[] farmKey = Convert.FromBase64String(System.Configuration.ConfigurationManager.AppSettings["Doconut:FarmKey"]);

Doconut.DoconutHost.Initialize(
    options =>
    {
        options.LicensePath = HostingEnvironment.MapPath("~/wwwroot/Doconut.Viewer.lic");
        options.AddPlugin<Doconut.Plugins.Converter.ConverterPlugin>();
        options.AddConverterWidget();
    },
    services => services.AddDoconutDistributedWidgets(store =>
    {
        store.RootPath = @"\\fileshare\doconut";   // en mapp som varje server kan läsa och skriva
        store.FarmKey = farmKey;                   // minst 32 byte, identisk på varje server
        // store.Ttl = TimeSpan.FromMinutes(30);   // hur länge en uppladdning sparas (standardvärdet)
    }));
  • En enskild server behöver inget: utan detta anrop används den minnesbaserade lagringen.
  • Uppladdningar och resultat är krypterade i vila på delningen (AES-256, encrypt-then-MAC), och varje fil är bunden till sin token, så en token kan aldrig läsa en annans fil.
  • På delningen behålls en uppladdning eller ett resultat i Ttl efter att den skrivits; att läsa den förlänger inte detta tidsfönster.
  • FarmKey måste vara minst 32 byte och identisk på alla servrar. Ladda den från en hemlig lagring; hårdkoda den aldrig. Registrering kastar ett ArgumentException när RootPath saknas eller FarmKey är kortare än 32 byte.
  • Peka RootPath på samma delade plats som den distribuerade visaren använder.

API-referens

Fasaden och widgetalternativen finns i namnrymden Doconut; ConversionTarget finns i Doconut.Configs.Conversion. ConverterPlugin finns i Doconut.Plugins.Converter.

DocumentConverter

csharp
public sealed class DocumentConverter
{
    public Task<Stream> ConvertAsync(
        string filePath, ConversionTarget target,
        string? password = null, CancellationToken ct = default);

    public Task<Stream> ConvertAsync(
        Stream source, string sourceExtension, ConversionTarget target,
        string? password = null, CancellationToken ct = default);

    public Task<Stream> WordToHtmlAsync(string filePath, CancellationToken ct = default);

    public Task<Stream> HtmlToWordAsync(
        Stream htmlSource, ConversionTarget outputFormat = ConversionTarget.Docx,
        CancellationToken ct = default);
}

Löst från DoconutHost.Services; konstruktorn är intern. sourceExtension inkluderar den inledande punkten. HtmlToWordAsync skriver en .doc-fil när outputFormat är ConversionTarget.Doc, och en .docx-fil för alla andra värden.

ConversionTarget

De 45 utdataformaten som listas i Målförformat.

ConverterWidgetOptions

csharp
public sealed class ConverterWidgetOptions
{
    public int MaxUploadMb { get; set; } = 25;
}

Ställ in via DoconutOptions.AddConverterWidget(Action<ConverterWidgetOptions>? configure = null), som returnerar DoconutOptions så att anrop kan kedjas.

Felsökning

SymptomOrsakÅtgärd
Varje begäran svarar med en tom 500 efter att pluginet lagts till; Windows händelseloggen (källa ASP.NET) visar The Converter plugin is registered via AddPlugin but no active license grants Converter.Ingen licens, en TRIAL-fil, en licens utan Converter, eller en betald licens utanför dess versionsfönsterInstallera en licens som ger Converter, eller ta bort AddPlugin<ConverterPlugin>()
Varje begäran svarar med en tom 500; händelseloggen visar AddConverterWidget() was called but the Converter plugin is not registered.Widgeten är aktiverad utan dess pluginLägg till options.AddPlugin<Doconut.Plugins.Converter.ConverterPlugin>()
Uppslagning av DocumentConverter kastar No IDocumentConverter is registered. Add the converter plugin: options.AddPlugin<Doconut.Plugins.Converter.ConverterPlugin>().ConverterPlugin är inte registreradLägg till AddPlugin<ConverterPlugin>() i DoconutHost.Initialize
En Web Forms-konvertering returnerar aldrigSidan blockerar på ConvertAsyncAnvänd Async="true" och RegisterAsyncTask
Strömkonvertering säger att formatet inte stödssourceExtension har ingen inledande punktSkicka ".xlsx", inte "xlsx"
ConvertAsync kastar Converting '.dcm' requires the Dicom capability license.En DICOM-källa, och licensen ger inte DicomAnvänd en licens som ger Dicom
Utdata är vattenmärktLicensen är tillfällig (Demo/NFR)Använd en betald licens som ger Converter
Widgeten laddas men dess begäranden returnerar 404AddConverterWidget() anropades inte, eller basePath är inte '/DocImage.axd'Anropa AddConverterWidget(); sätt basePath: '/DocImage.axd'
En stor uppladdning visar en IIS-felsida istället för widgetens meddelandemaxRequestLength / maxAllowedContentLength är under MaxUploadMbHöj Web.config-gränserna över MaxUploadMb
open svarar 403 Converting this file type requires the Dicom capability license.En DICOM-uppladdning, och licensen ger inte DicomAnvänd en licens som ger Dicom
run svarar 400 That target format is not available for this file.Målet är inte ett av källans allowedTargetsErbjud endast allowedTargets från convert=open
run eller download svarar 404 (Upload expired — please re-open the file. från run)30-minutersfönstret har löpt ut, eller så har en annan server i en farm inte uppladdningenÖppna filen igen; i en farm, registrera AddDoconutDistributedWidgets
Widgeten misslyckas när UI:t är på en annan ursprungSlutpunkterna har inget CORS-stödServera UI:t från samma ursprung, eller omvänd proxy Doconut-sökvägarna
Temat tillämpas inteVariablerna är satta på en förfader eller på ett element inuti mounten; widgetens egen .dcw-regel sätter dem på mountenMål mot själva mounten: #doconut-convert.dcw eller #doconut-convert

Noteringar om ramverket

Jämfört med ASP.NET Core-paketen skiljer sig detta paket endast i hosting; API:et, slutpunktskontraktet, widgetskriptet och licensreglerna är desamma.

  • Registrering är i Application_Start, via DoconutHost.Initialize, istället för builder.Services.AddDoconut. Tjänster som AddDoconutDistributedWidgets går i dess andra argument.
  • Slutpunkter serveras av DocImage.axd och skriptet av DoconutResourceModule, båda registrerade i Web.config, istället för UseDoconut() och UseDoconutResources(). Widgeten behöver basePath: '/DocImage.axd'.
  • Startfel visas som en tom 500 på varje begäran, med orsaken i Windows händelseloggen.
  • Uppladdningar läses helt av ASP.NET innan Doconut ser dem, så IIS-gränserna måste vara över MaxUploadMb.
  • Web Forms-sidor får inte blockera på en konvertering; se I Web Forms.
  • Endast Windows, likt resten av .NET Framework-paketet.

Var den här sidan hjälpsam?