Migrare a .NET Standard 2.1
Spostare un'applicazione Doconut.NETStandard esistente da 26.7.0 a 26.8.0
Doconut ha due integrazioni .NET Standard distinte. Usano lo stesso nome di pacchetto Doconut.NETStandard, quindi identifica la generazione dalla versione e dalle API nell'applicazione prima di modificare pacchetti, avvio, licenze o risorse del browser.
La versione è il bivio
Entrambe le generazioni pubblicano sotto lo stesso ID pacchetto. Solo la versione le distingue:
| Versione | Obiettivo | API |
|---|---|---|
| 26.7.0 e versioni precedenti | netstandard2.0 | l'API precedente |
| 26.8.0 e versioni successive | netstandard2.1 | l'API corrente |
Incrementare il numero di versione è l'aggiornamento. Non esiste un pacchetto separato da installare né uno shim di compatibilità — 26.8.0 è una superficie API diversa. Aspettati errori di compilazione dopo l'incremento; il resto di questa guida è l'elenco di essi.
Quale integrazione stai usando?
| Se il progetto contiene… | Generazione |
|---|---|
new Viewer(_cache, _accessor, ...) | Precedente |
viewer.OpenDocument(...) (synchronous) | Precedente |
viewer.InitCache() | Precedente |
UseDoconut(new DoconutOptions { ... }) | Precedente |
UseDoconutWebFarm(...) / WebFarmOptions | Precedente |
Viewer.DoconutLicense(...) o Viewer.SetLicensePlugin(...) | Precedente |
viewer.Converter.GetConverter() | Precedente |
using Doconut.Configs; / using Doconut.Models; | Precedente |
Copiati manualmente docViewer.js, documentLinks.js o docViewer.UI.js | Precedente |
builder.Services.AddDoconut(...) | Corrente |
app.UseDoconutResources() più app.UseDoconut() senza argomenti | Corrente |
Viewer supplied by dependency injection | Corrente |
await viewer.OpenDocumentAsync(...) | Corrente |
Se entrambe le colonne compaiono nella stessa applicazione, considera la migrazione incompleta. Non inviare un token documento attraverso risorse o middleware della generazione opposta.
Controlla prima il framework host
Questo è un vincolo rigido, non una preferenza. Il pacchetto corrente mira a netstandard2.1:
| Host | Può consumare 26.8.0 |
|---|---|
| .NET Core 3.0 o versioni successive (inclusi .NET 5/6/7/8) | Sì |
| .NET Framework, qualsiasi versione | No |
.NET Framework non può fare riferimento a una libreria netstandard2.1. Se l'applicazione gira su .NET Framework, fermati qui e usa il pacchetto Doconut.NETFramework invece; dalla 26.9.0 richiede .NET Framework 4.7.2. Entrambe le applicazioni di riferimento per questa versione puntano a net8.0.
Prima di migrare
- Crea un ramo e una copia di sicurezza distribuibile dell'applicazione esistente.
- Registra le versioni esatte dei pacchetti principali e delle estensioni.
- Fai l'inventario di ogni chiamata
new Viewer(...), chiamataInitCache(), chiamata di caricamento licenza, mappaturaUseDoconutWebFarm, controllore di conversione, programma Doconut copiato, azione della barra degli strumenti personalizzata, richiamo del viewer e punto finale di apertura documento. - Conserva i file
.licattuali e i segreti di distribuzione al di fuori del controllo versione. - Acquisisci un insieme rappresentativo di documenti PDF, Office, immagine, CAD, email, DICOM, ricercabili, protetti da password e annotati.
- Registra il tempo di scadenza della sessione esistente, il comportamento di sicurezza, i caratteri e le impostazioni della piattaforma.
Migra un ambiente prima di modificare la produzione. L'integrazione corrente modifica la durata del servizio, l'instradamento delle richieste, la proprietà della sessione, la consegna delle risorse client e — se gestisci un gruppo di server — il modo in cui le pagine raggiungono il browser.
1. Namespace: quasi tutto spostato nella radice
I tipi di configurazione erano distribuiti su quattro namespace. Ora sono tutti in Doconut.
| Prima | Ora |
|---|---|
using Doconut.Configs.View; | using Doconut; |
using Doconut.Models; | using Doconut; |
using Doconut.Configs; | using Doconut; |
using Doconut.Configs.Cloud; | using Doconut.Clouds; |
using Doconut.Configs.Conversion; | invariato |
using Doconut.Middleware; | invariato |
I nomi dei tipi non sono cambiati: WordConfig, PdfConfig, ExcelConfig, CssConfig, ScriptConfig, CloudUploadConfig, AzureConfig, CDNConfig, FileShareConfig e il resto è ancora presente. Nella maggior parte dei file l'intera modifica consiste nell'eliminare due righe using.
Doconut.Configs.Editor (BaseConfigEditor, PdfConfigEditor) è stato rimosso e non ha alcuna sostituzione in questo pacchetto. Se la tua applicazione faceva riferimento a quei tipi, pianifica quella parte separatamente e non considerarla parte di questa migrazione.
2. Compatibilità di pacchetto e licenza
Sostituisci o aggiorna deliberatamente il pacchetto core; non fare affidamento sull'ID pacchetto identico per selezionare la nuova API. Il comando predefinito installa l'ultima versione stabile:
dotnet add package Doconut.NETStandardPer una migrazione riproducibile alla versione verificata da questa guida, passa la versione come opzione separata:
dotnet add package Doconut.NETStandard --version 26.9.0Mantieni ogni plugin Doconut alla stessa versione del pacchetto core — Doconut.NETStandard.Converter e Doconut.NETStandard.Dicom. L'integrazione attuale carica le licenze una volta durante AddDoconut(), usando questa precedenza:
LicenseStream > LicenseContent > LicensePath > automatic discoveryIl rilevamento automatico cerca Doconut.Viewer.lic e i file Doconut.Viewer.<Capability>.lic di accompagnamento. Le precedenti chiamate statiche Viewer.DoconutLicense(...) e Viewer.SetLicensePlugin(...) non costituiscono un meccanismo di avvio attuale, né lo è il List<string> dei percorsi di licenza che il vecchio costruttore Viewer accettava. Sposta la licenza su DoconutOptions, mantieni i file di accompagnamento insieme quando usi il rilevamento automatico, riavvia dopo aver modificato una licenza e verifica le capacità tramite IDoconutLicenseService.
Non presumere che la presenza di una vecchia licenza del plugin dimostri il diritto per una build del plugin corrente. Testa Viewer, Search, Annotation, Converter e DICOM separatamente con gli artefatti di rilascio approvati.
3. Avvio e iniezione delle dipendenze
In precedenza il viewer veniva costruito per ogni richiesta e le opzioni venivano passate al middleware:
// Integrazione precedente — solo a scopo di confronto; non compilare questo con l'SDK corrente.
var viewer = new Viewer(_cache, _accessor);
// …
appBranch.UseDoconut(new DoconutOptions { UnSafeMode = false, ShowDoconutInfo = false });L'integrazione attuale registra Doconut una sola volta e riceve Viewer dall'iniezione delle dipendenze:
builder.Services.AddDoconut(options =>
{
options.UnsafeMode = false; // nota il cambiamento di ortografia: UnSafeMode → UnsafeMode
options.ShowDoconutInfo = false;
options.LicensePath = "Doconut.Viewer.lic";
});
builder.Services.AddDistributedMemoryCache(); // lo stato di sessione richiede una cache (MVC/Razor Pages ne aggiunge già una)
builder.Services.AddSession();
app.UseSession();
app.UseDoconutResources();
app.UseDoconut();Viewer è un servizio transitorio. Il gestore della sessione documento e la sua cache possiedono lo stato del documento a più lungo termine, non l'istanza Viewer iniettata specifica.
Tre cose da mantenere:
new Viewer(cache, accessor)è scomparso. IniettaDoconut.Viewernel tuo controller, o usa@inject Doconut.Viewer Viewerin una vista Razor.UseDoconutResources()sostituisce il wiring manualeapp.UseMiddleware<EmbeddedResourceMiddleware>(), e deve essere eseguito prima del ramo del documento.UnSafeMode→UnsafeMode. Una rinomina di un carattere il compilatore la rileverà.
Quando UnsafeMode è false l'SDK valida il token di sessione rispetto alla richiesta originaria, quindi AddSession() / UseSession() devono ancora trovarsi nella pipeline, UseSession() prima del ramo.
Metodi che non esistono più
| Prima | Ora |
|---|---|
viewer.OpenDocument(path, config, options) | await viewer.OpenDocumentAsync(path, config, options) |
viewer.InitCache() | rimosso — non c'è nulla da avviare manualmente; elimina la chiamata e qualsiasi flag “ho già inizializzato?” attorno ad essa |
viewer.ExportToPng(sharedPath) | vedi §7 |
viewer.ExportToCloud(cloudConfig) | vedi §7 |
using var v = new Viewer(...); v.CloseDocument(t) | viewer.CloseDocument(token) sull'istanza iniettata |
4. Middleware e routing delle risorse
UseDoconut() ora non accetta argomenti. La forma del ramo MapWhen non deve cambiare — solo il middleware al suo interno:
app.UseDoconutResources(); // PRIMA del branch
app.MapWhen(
ctx => ctx.Request.Path.Value?.EndsWith("DocImage.axd", StringComparison.OrdinalIgnoreCase) == true,
branch => branch.UseDoconut());Nella pipeline attuale:
- chiama
UseSession()prima di Doconut mentre la sicurezza della sessione è abilitata; - chiama
UseDoconutResources()prima diUseDoconut(); - mantieni
ResourcesPath, gli URL delle risorse generate e il clientResPathallineati; - mantieni il ramo che mappi e il client
BasePathallineati.
MiddlewarePath è una configurazione validata; non crea un ramo ASP.NET Core da solo.
5. Costruzione e durata del visualizzatore
Rimuovi le cache di proprietà dell'applicazione per gli oggetti Viewer. Non rimane nulla in un Viewer
che valga la pena conservare: non contiene alcuno stato del documento, e la cache della sessione possiede tutto
ciò che sopravvive a una richiesta. Iniettalo in un endpoint, pagina Razor, controller o servizio
applicativo a livello scoped:
app.MapPost("/api/open", async (Viewer viewer) =>
{
var token = await viewer.OpenDocumentAsync("wwwroot/files/Sample.pdf");
return Results.Ok(new { token });
});Il token restituito identifica una sessione di documento lato server. Trattalo come una credenziale di tipo bearer
: non registrarlo, non conservarlo né inserirlo nelle analisi.
6. Apertura e chiusura dei documenti
Sostituisci il OpenDocument(...) sincrono con OpenDocumentAsync(...):
// Integrazione attuale: Viewer proviene da DI e l'apertura del documento è asincrona.
var token = await viewer.OpenDocumentAsync(path, new PdfConfig { AllowSearch = true });Le overload attuali accettano un percorso file o uno stream, una configurazione di formato opzionale,
DocOptions opzionale e un token di cancellazione. Chiudi esplicitamente la sessione server quando
il browser non ne ha più bisogno:
viewer.CloseDocument(token);Elimina qualsiasi chiamata InitCache() e il flag che la protegge — non c'è nulla da preriscaldare manualmente.
Non riutilizzare un token generato dalla libreria precedente dopo la migrazione: apri nuovamente ogni
documento tramite l'API corrente.
7. Web farm → distribuito: il cambiamento più grande
UseDoconutWebFarm e WebFarmOptions non esistono più. Se la tua app li chiama,
questa sezione è il tuo aggiornamento; se non lo fa, passa a §8.
In precedenza un unico middleware gestiva tutto: serviva immagini pre-renderizzate da una cartella condivisa,
e pollava mentre un altro nodo le stava ancora scrivendo.
// Integrazione precedente — una chiamata, coordinazione implicita tramite il file system.
appBranch.UseDoconutWebFarm(new WebFarmOptions
{
Path = Path.Combine(env.WebRootPath, "webfarm"),
PageWaitTimeSeconds = 180,
StartWaitFromPage = 5,
});Lo stesso compito ora è suddiviso in due metà esplicite. Lato scrittura — il nodo che apre
il documento pubblica l'intero set di artefatti (pagine, informazioni del documento, indice di ricerca,
metadati) nella condivisione:
var result = await _publisher.PublishAsync( // DistributedDocumentPublisher, iniettato da DI
pathToFile,
new FileShareConfig
{
Location = CloudLocation.FileShare,
RootPath = @"\\fileserver\doconut", // la stessa cartella che usi oggi
UsePerTokenSubfolders = true,
},
config,
documentOptions,
new DistributedDocumentPublishOptions
{
CleanUpStagingDirectory = true,
FirstPagePriority = true,
});
return Content(result.Token);Lato lettura — qualsiasi nodo serve dalla condivisione:
app.MapWhen(
ctx => ctx.Request.Path.Value?.EndsWith("DocImage.axd", StringComparison.OrdinalIgnoreCase) == true,
branch => branch.UseDoconutCloud<FileShareCloudHandler>(options =>
{
options.Location = CloudLocation.FileShare;
options.CloudUploadConfig = /* lo STESSO FileShareConfig come sopra */;
}, "/"));| Prima | Ora |
|---|---|
WebFarmOptions.Path | FileShareConfig.RootPath |
PageWaitTimeSeconds / StartWaitFromPage | scomparso — sostituito da FirstPagePriority sul lato scrittura più FileShareConfig.ReadReadyPollMs sul lato lettura |
viewer.OpenDocument(...) poi viewer.ExportToPng(share) | una chiamata PublishAsync(...) |
DocOptions.IsWebfarm / WebfarmPath | ancora presente, scritto IsWebFarm / WebFarmPath — ma non necessario nel percorso di pubblicazione |
La tua topologia non cambia. Punta RootPath sulla stessa condivisione UNC e ogni nodo
continua a funzionare come fa oggi. Ciò che cambia è che la pubblicazione è un'operazione che
chiami, invece di un effetto collaterale del rendering.
Entrambe le metà devono concordare. Se
RootPathoUsePerTokenSubfoldersdifferiscono tra il
publisher e l'handler, l'altro nodo risponde 404. Costruisci la configurazione in un helper
e chiamala da entrambe le parti.
PageWaitTimeSeconds = 180 significava "bloccare fino a tre minuti sperando che la pagina appaia". Il
sostituto è esplicito: con FirstPagePriority = true, la pagina 1 è servibile immediatamente
e le pagine successive rispondono HTTP 202 Accepted fino a quando non sono scritte. Il visualizzatore integrato riprova
automaticamente quando retryOn409 è impostato. Un client che non riprova mostrerà
tessere per le pagine ancora in rendering.
L'intera configurazione, inclusa la pubblicazione in background e i ticket di accesso, è su
Distribuzioni distribuite.
8. La conversione è un plugin, ed è molto più piccola
Registra il plugin, poi inietta la facciata DocumentConverter:
builder.Services.AddDoconut(o => o.AddPlugin<ConverterPlugin>());// Integrazione precedente
var converter = viewer.Converter.GetConverter();
var config = new WordConfigConverter { TargetFormat = WordConfigConverter.EnTargetFormat.PDF };
var result = converter.Convert(stream, SourceFormatConverter.DOCX, config);
// Integrazione corrente
var result = await _converter.ConvertAsync(stream, ".docx", ConversionTarget.Pdf, null, ct);Ciò che sostituisce:
SourceFormatConverter— rimosso. Passa l'estensione del file come stringa, includendo il punto.- I tipi
*ConfigConverterper famiglia (WordConfigConverter,ExcelConfigConverter, …), ognuno con un enumEnTargetFormatannidato — rimosso. Ora c'è un enumConversionTargetper ogni famiglia. viewer.Converter.GetConverter()— rimosso. IniettaDoconut.DocumentConverter.
ConvertAsync restituisce uno stream ricercabile, quindi return File(result, mime, name) funziona direttamente — la copia MemoryStream del vecchio codice necessario è superflua. Nell'esempio fornito questo ha eliminato uno switch di estensioni con 68 casi e dieci controller quasi identici.
Vedi Plugin di conversione per l'intera superficie.
9. Provider cloud
UseDoconutCloud è diventato generico. Il provider è l'argomento di tipo invece di un valore Location su cui si effettuava lo switch all'interno del middleware:
// Integrazione precedente
appBranch.UseDoconutCloud(new CloudOptions { Location = CloudLocation.CDN, ... });
// Integrazione corrente
branch.UseDoconutCloud<CDNCloudHandler>(options =>
{
options.Location = CloudLocation.CDN;
options.CloudUploadConfig = new CDNConfig { DoconutCdnUrl = "..." };
}, "/");Le classi di configurazione sono invariate tranne che per lo spazio dei nomi (Doconut.Configs.Cloud → Doconut.Clouds): AzureConfig, AmazonConfig, GoogleCloudConfig, DropBoxConfig, RedisConfig, CDNConfig, FTPConfig, più il nuovo FileShareConfig. I gestori sono denominati <Provider>CloudHandler.
Il gestore CDN è sola lettura — serve ciò che è già sul CDN; non carica nulla.
10. Oggetti di configurazione che hanno cambiato nome
| Prima | Ora |
|---|---|
DoconutOptions.UnSafeMode | UnsafeMode |
DocOptions.IsWebfarm | IsWebFarm |
DocOptions.WebfarmPath | WebFarmPath |
DocOptions.ImageResolution | ancora presente ma obsoleta — imposta la risoluzione sulla configurazione del formato invece |
DocOptions guadagna anche IsSecured.
L'API attuale separa anche le preoccupazioni in modo più rigoroso rispetto alla precedente, quindi verifica che ogni impostazione sia sull'oggetto che ora la possiede:
| Aspetto | Tipo corrente |
|---|---|
| Percorsi middleware, licenze, registrazione plugin | DoconutOptions |
| Password, timeout, sicurezza, watermark | DocOptions |
| Rendering del formato e DPI | PdfConfig, WordConfig, ExcelConfig, e altri tipi BaseConfig |
| Predefiniti del widget del browser | ViewerConfig o le equivalenti opzioni JavaScript |
| CSS e script generati | CssConfig e ScriptConfig |
| Archiviazione condivisa e provider cloud | FileShareConfig e le altre configurazioni Doconut.Clouds |
Non portare avanti DocOptions.ImageResolution come controllo di rendering. È obsoleto; imposta BaseConfig.ImageResolution sulla configurazione specifica del formato. Rivedi tutte le impostazioni predefinite invece di presumere che una configurazione precedente abbia lo stesso comportamento.
11. Il visualizzatore client-side — due cambiamenti che falliscono SILENTIAMENTE
Entrambi lasciano il server funzionante perfettamente. Il tuo documento viene renderizzato, la pagina appare corretta e nulla compare nella console del browser. Leggi questa sezione anche se il tuo C# compila al primo tentativo.
I callback del visualizzatore sono ora opzioni, non funzioni globali
Il visualizzatore precedente chiamava i tuoi gestori per nome, derivando il nome della funzione globale dall'ID del contenitore. Dichiarare function ctlDoc_OnViewerReady() su una pagina con <div id="div_ctlDoc"> era sufficiente. Il visualizzatore attuale accetta callback espliciti nell'oggetto opzioni e non cerca più quelle funzioni globali:
objctlDoc = $("#div_ctlDoc").docViewer({
// ... le tue opzioni esistenti ...
onViewerBusy: ctlDoc_OnViewerBusy, // è stato trovato per nome
onViewerReady: ctlDoc_OnViewerReady, // è stato trovato per nome
onCopy: ctlDoc_Copy, // era ctlDoc_Copy(text)
onAutoLoadStatus: ctlDoc_AutoLoadStatus // era ctlDoc_AutoLoadStatus(page)
});Perché è problematico: la vecchia chiamata era avvolta in un catch vuoto, che inghiottiva tutto. Ora le tue funzioni semplicemente non vengono mai eseguite e nulla segnala un errore. Il sintomo usuale è uno spinner attivo che non si ferma mai — perché la funzione che lo nascondeva era ctlDoc_OnViewerReady. Il documento dietro di esso è a posto.
L'elenco completo delle opzioni è onPageLoading, onPageLoaded, onThumbnailClicked, onPageClicked, onDoubleClick, onViewerBusy, onViewerReady, onViewerError, onCopy, onAnnSaved, onAnnSaveError, onAnnLoaded, onAnnClosed, onAutoLoadStatus, onThumbsShown e onError. Non esiste un callback per il click sui link: la gestione degli hyperlink è integrata, guidata da showHyperlinks.
ResPath deve puntare al prefisso della risorsa
ResPath: '', // PRIMA — le risorse provenivano dalla radice dell'applicazione
ResPath: 'doconut-res/images', // ORA — il prefisso UseDoconutResources() montaSe hai modificato il prefisso tramite DoconutOptions.ResourcesPath, usa quel valore al suo posto.
12. Barra degli strumenti del Viewer, Ricerca e Annotazione
Non migrare gli script vecchi uno per uno. Le attuali applicazioni di riferimento compongono un pacchetto di pagina completo:
- emettere il CSS del Viewer e il CSS della Ricerca/Annotazione con licenza tramite
ReferenceCss; - renderizzare la barra degli strumenti del Viewer di proprietà dell'applicazione;
- renderizzare
searchBarMount,annBarMounte il mount del Viewer richiesto; - emettere gli script del Viewer e dei moduli con licenza con
ReferenceScripts; - caricare lo script di supporto della barra degli strumenti dell'applicazione;
- inizializzare un
objViewer; - inizializzare i Ribbon di Ricerca e Annotazione con licenza;
- chiamare
attach(objViewer)su ogni Ribbon; - aprire il documento e chiamare
objViewer.View(token).
Ricerca e Annotazione sono moduli collegati allo stesso Viewer, non barre degli strumenti indipendenti. La barra degli strumenti principale appartiene all'applicazione host; i Ribbon di Ricerca e Annotazione sono risorse incorporate, con accesso basato sulle capacità.
Rimuovere i file copiati manualmente come documentLinks.js e docViewer.UI.js solo dopo che la pagina corrente funziona con le risorse emesse da ReferenceCss e ReferenceScripts.
13. Registrazione dei plugin
I metodi statici di licenza dei plugin non registrano i plugin attuali. Installa e registra esplicitamente ogni pacchetto rilasciato:
builder.Services.AddDoconut(options =>
{
options.AddPlugin<Doconut.Plugins.Converter.ConverterPlugin>();
options.AddPlugin<Doconut.Plugins.Dicom.DicomPlugin>();
});AddDoconut() convalida le capacità dei plugin registrati all'avvio. Converter e DICOM sono i plugin .NET Standard rilasciati. Ricerca e Annotazione normali sono funzionalità con licenza integrate, non pacchetti AddPlugin<TPlugin>().
14. Sicurezza della sessione e del documento
L'integrazione attuale associa i documenti a token opachi e sessioni cache. Con il valore predefinito UnsafeMode = false, UseDoconut() aggiunge la sicurezza di accesso al documento e l'host deve configurare la sessione ASP.NET:
builder.Services.AddDistributedMemoryCache(); // lo stato della sessione necessita di una cache (MVC/Razor Pages ne aggiunge già una)
builder.Services.AddSession();
app.UseSession();Mantieni DocOptions.IsSecured = true a meno che un progetto revisionato non richieda diversamente. Non usare mai UnsafeMode = true come scorciatoia di migrazione su un singolo nodo. Testa le richieste senza token, con token malformato, token scaduto e token da una sessione del browser diversa.
In un farm, la richiesta della pagina può arrivare su un nodo che non ha mai visto la richiesta iniziale, quindi il controllo per sessione la rifiuterebbe. Questo è l'unico caso in cui UnsafeMode = true è corretto — e deve essere accoppiato con ticket di accesso firmati tramite AddDoconutDistributedDocumentSecurity, non distribuito da solo. Vedi Distribuzioni distribuite.
Nota sulla denominazione
In tutti i framework la classe è Viewer. Se trovi DocumentViewer in snippet vecchi o articoli di terze parti, quel tipo non è mai esistito nell'SDK.
15. Ordine di lavoro suggerito
- Conferma che il framework host possa consumare netstandard2.1. Se non può, fermati.
- Aggiorna il pacchetto a 26.8.0 e compila. Risolvi gli errori di compilazione — la maggior parte sono le righe
usingnella §1. - Sposta l'avvio su
AddDoconut()e le chiamate al middleware nel nuovo ordine (§3, §4). - Inietta
Viewerdove lo stavi costruendo, rendiOpenDocumentasincrono e eliminaInitCache()(§5, §6). - Se usi il web farm, esegui §7 — l'unica parte che è una riprogettazione piuttosto che una rinomina.
- Se converti i documenti, esegui §8.
- Esegui §11 — le modifiche lato client. Sono quelle che non si annunceranno da sole.
- Apri un documento reale in un browser e osserva lo spinner di caricamento. Una build verde non dimostra nulla qui: licenza, registrazione dei plugin, il percorso della risorsa e le callback del viewer falliscono tutti solo a runtime. Per un farm, verifica che un documento pubblicato da un nodo sia servito da un altro.
Test della migrazione
Al minimo, verificare:
- avvio dell'applicazione con la licenza di produzione e tutti i plugin registrati;
- CSS/script del Viewer e tutte le richieste di pagina-immagine nei percorsi scelti;
- apertura del documento, navigazione, zoom, miniature, stampa e chiusura esplicita;
- ricerca in un documento con testo e lo stato non ricercabile di un file solo immagine;
- caricamento, salvataggio, esportazione delle annotazioni e controllo delle capacità;
- scoperta del target del convertitore, output, download e stato del watermark;
- pagine DICOM, fotogrammi e animazione; i metadati tecnici non sono disponibili in questo pacchetto;
- documenti protetti da password, font personalizzati, testo non latino e timeout configurati;
- rifiuto del token tra sessioni e comportamento di sessione scaduta;
- per un farm: pubblicare su un nodo, richiedere una pagina tardiva da un altro e confermare che il viewer riprovi le risposte
202invece di mostrare tile rotti; - mobile, modalità scura e il percorso reverse-proxy di produzione.
Piano di rollback
Conserva l'artefatto di distribuzione precedente, i pacchetti corrispondenti, i file di licenza e le risorse del browser copiate insieme. Un rollback sicuro cambia l'intera generazione dell'applicazione; non mescola un server di generazione precedente con gli script attuali, né un server attuale con i siti di chiamata new Viewer(...).
Prima del taglio, documentare:
- lo slot di distribuzione o l'artefatto usato per il rollback;
- l'impatto dello storage condiviso, se presente — gli artefatti pubblicati da 26.8.0 non sono consumati dal middleware del web-farm precedente;
- come le sessioni di documento attive saranno invalidate;
- il controllo di salute e il documento di prova usati per decidere il rollback;
- chi può ripristinare il set di pacchetti e la configurazione precedenti.
Documentazione legacy
Il manuale precedente tradotto rimane disponibile su Configurazione Legacy .NET Standard. Il Gateway di integrazione precedente spiega gli stessi segnali di identificazione e rimanda a questa guida di migrazione.
Conserva l'URL storico nei segnalibri e nei ticket di supporto finché le installazioni netstandard2.0 esistono ancora. Documenta una generazione diversa e non è reindirizzato all'API corrente.
Questa pagina è stata utile?