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.
| Yta | Nä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
Install-Package Doconut.NETFramework.ConverterFör att låsa pluginet till den version som den här dokumentationen beskriver:
Install-Package Doconut.NETFramework.Converter -Version 26.10.0Behå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.
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:
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
| Licensstatus | Uppstart | Konverteringsresultat |
|---|---|---|
Betald visningslicens som ger Converter, inom dess versionsfönster | Startar | Ren — watermarked: false |
| Aktiv tillfällig (Demo/NFR) licens | Startar | Konverterar, med utvärderingsvattenstämpeln — watermarked: true |
| Utgången tillfällig (Demo/NFR) licens | Startar | Konverterar, med utvärderingsvattenstämpeln — watermarked: true |
Ingen licens, en äldre TRIAL‑fil, en licens utan Converter, eller en betald licens utanför dess versionsfönster | Application_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.
// 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);// 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);Stream html = await converter.WordToHtmlAsync("report.docx", ct);// 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:
[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:
<%@ Page Language="C#" Async="true" CodeBehind="Convert.aspx.cs" Inherits="MyApp.Convert" %>// 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:
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, IcoInte 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:
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:
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 slutpunkternaDocImage.axd‑hanteraren frånWeb.config.- Skriptet och slutpunkterna är oberoende. Resursmodulen levererar
doconutConverter.jsoavsett om widgeten är aktiverad eller inte. UtanAddConverterWidget()laddas widgeten, målar sin drozzon och ser helt korrekt ut — och dess första åtgärd svarar404.
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:
<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
<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
| Alternativ | Typ | Standard | Anteckningar |
|---|---|---|---|
basePath | string | /doconut | Endpoint‑URL:en. Ställ in '/DocImage.axd' på detta paket |
resPath | string | /doconut-res | Accepterad för konsistens med andra Doconut‑widgetar; konverteringswidgeten bygger ingen URL från den |
maxUploadMb | number | 25 | Endast förhandskontroll på klienten; servern upprätthåller sin egen gräns |
licenseUrl | string | null | null | Gör vattenstämpelmeddelandet på resultatskärmen till en länk |
labels | object | {} | Åsidosätter någon delmängd av widgetens engelska strängar |
Återuppringningar
| Återuppringning | Utlöses när | Innehåll |
|---|---|---|
onReady() | Widgeten har renderat sin droppskärm | — |
onSourceLoaded({ token, pages, sourceExt, allowedTargets }) | ?convert=open lyckas | Källtoken, sidantal, källa‑filändelse (utan inledande punkt), tillåtna mål |
onConverted({ downloadToken, resultToken, resultPages, downloadName, watermarked, target }) | ?convert=run lyckas | Körningssvaret plus den begärda target |
onDownload({ downloadName, downloadToken }) | Användaren klickar på Download | Utlöses parallellt med webbläsarens egen nedladdning |
onError({ phase, message }) | En öppnings‑ eller körningsbegäran misslyckas | phase ä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:
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 dettaEtiketter
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'.
| Nyckel | Engelsk standard |
|---|---|
dropPrompt | Drag & drop a document here |
dropHint | PDF, Word, Excel, PowerPoint, images and more |
chooseFile | Choose file |
uploading | Uploading {name}… |
page / pages | 1 page / {n} pages |
noTargets | No conversion targets are available for this file. |
convertTo / convert | Convert to / Convert |
converting | Converting to {target}… |
readyToDownload | Ready to download |
download / convertAnother | Download / Convert another |
watermarkNotice | Output is watermarked — get a license to remove it. |
retry | Retry |
genericError | Something went wrong. Please try again. |
sizeLimit | That file is larger than the {mb} MB upload limit. Please choose a smaller file. |
serverError | The server could not process this request. Please try again. |
networkError | Could 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:
#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.
| Rutt | Syfte | Svar vid lyckat anrop |
|---|---|---|
POST /DocImage.axd?convert=open (multipart, one file) | Ladda upp och öppna ett källdokument | 200 — { token, pages, sourceExt, allowedTargets } |
POST /DocImage.axd?token=<token>&convert=run&target=<ext> | Konvertera den uppladdade källan till target | 200 — { downloadToken, resultToken, resultPages, downloadName, watermarked } |
GET /DocImage.axd?convert=download&token=<downloadToken> | Strömma den konverterade filen | 200 — 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.
| Rutt | Status | När | Kropp |
|---|---|---|---|
| valfri | 404 | Widgeten är inte aktiverad (AddConverterWidget() anropades aldrig) | endast status |
| valfri | 405 | Fel verb (open/run kräver POST, download kräver GET) | endast status |
open | 400 | Ingen multipart‑uppladdning | Expected a multipart file upload. |
open | 400 | Ingen fil, eller en tom fil | No file uploaded. |
open | 400 | En typ som inte kan konverteras | This file type cannot be converted. |
open | 403 | Filtypen kräver en funktion som licensen inte beviljar (en DICOM‑fil utan Dicom) | Converting this file type requires the Dicom capability license. |
open | 413 | Uppladdningen överskrider MaxUploadMb (men inte IIS‑gränserna) | File is too large. |
run | 400 | En felaktig token (inte ett GUID) | Invalid token. |
run | 400 | En target som inte kan parsas till en ConversionTarget | Unknown target format. |
run | 400 | Ett mål som inte finns i allowedTargets | That target format is not available for this file. |
run | 404 | Uppladdningen har gått ut eller öppnades aldrig | Upload expired — please re-open the file. |
open, run | 500 | Bearbetning misslyckades | Ett sanerat meddelande |
download | 400 / 404 | En felaktig, okänd eller utgången nedladdningstoken | endast status |
En komplett rundresa med fetch:
// 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
- Installera pluginet bredvid kärnpaketet, i samma version:
Install-Package Doconut.NETFramework.Converter. - Lägg till licensfilen. Placera
Doconut.Viewer.Converter.lici samma mapp somDoconut.Viewer.lic. - Ställ in uppladdningsgränserna.
MaxUploadMbiAddConverterWidgetär den gräns som Doconut upprätthåller; hållmaxRequestLengthochmaxAllowedContentLengthiWeb.configöver den (se Uppladdningsgränser), och widgetensmaxUploadMblika med den. - Blockera aldrig en konvertering i Web Forms (se I Web Forms).
- Disposera konverteringsresultat. Strömmen
ConvertAsyncreturnerar ä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:
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
Ttlefter att den skrivits; att läsa den förlänger inte detta tidsfönster. FarmKeymåste vara minst 32 byte och identisk på alla servrar. Ladda den från en hemlig lagring; hårdkoda den aldrig. Registrering kastar ettArgumentExceptionnärRootPathsaknas ellerFarmKeyär kortare än 32 byte.- Peka
RootPathpå 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
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
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
| Symptom | Orsak | Å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önster | Installera 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 plugin | Lä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 registrerad | Lägg till AddPlugin<ConverterPlugin>() i DoconutHost.Initialize |
| En Web Forms-konvertering returnerar aldrig | Sidan blockerar på ConvertAsync | Använd Async="true" och RegisterAsyncTask |
| Strömkonvertering säger att formatet inte stöds | sourceExtension har ingen inledande punkt | Skicka ".xlsx", inte "xlsx" |
ConvertAsync kastar Converting '.dcm' requires the Dicom capability license. | En DICOM-källa, och licensen ger inte Dicom | Använd en licens som ger Dicom |
| Utdata är vattenmärkt | Licensen är tillfällig (Demo/NFR) | Använd en betald licens som ger Converter |
Widgeten laddas men dess begäranden returnerar 404 | AddConverterWidget() 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 meddelande | maxRequestLength / maxAllowedContentLength är under MaxUploadMb | Hö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 Dicom | Anvä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 allowedTargets | Erbjud 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 ursprung | Slutpunkterna har inget CORS-stöd | Servera UI:t från samma ursprung, eller omvänd proxy Doconut-sökvägarna |
| Temat tillämpas inte | Variablerna är satta på en förfader eller på ett element inuti mounten; widgetens egen .dcw-regel sätter dem på mounten | Må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, viaDoconutHost.Initialize, istället förbuilder.Services.AddDoconut. Tjänster somAddDoconutDistributedWidgetsgår i dess andra argument. - Slutpunkter serveras av
DocImage.axdoch skriptet avDoconutResourceModule, båda registrerade iWeb.config, istället förUseDoconut()ochUseDoconutResources(). Widgeten behöverbasePath: '/DocImage.axd'. - Startfel visas som en tom
500på 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?