Migrar a .NET Standard 2.1

Mover una aplicación Doconut.NETStandard existente de 26.7.0 a 26.8.0

Doconut tiene dos integraciones distintas de .NET Standard. Utilizan el mismo nombre de paquete Doconut.NETStandard, por lo que debe identificar la generación a partir de la versión y las API en la aplicación antes de cambiar paquetes, inicio, licencias o recursos del navegador.

La versión es la bifurcación del camino

VersiónObjetivoAPI
26.7.0 y anterioresnetstandard2.0la API anterior
26.8.0 y posterioresnetstandard2.1la API actual

Incrementar el número de versión es la actualización. No hay un paquete separado para instalar y no hay un shim de compatibilidad — 26.8.0 es una superficie de API diferente. Espere errores de compilación después del incremento; el resto de esta guía es la lista de ellos.

¿Qué integración está utilizando?

Si el proyecto contiene…Generación
new Viewer(_cache, _accessor, ...)Anterior
viewer.OpenDocument(...) (synchronous)Anterior
viewer.InitCache()Anterior
UseDoconut(new DoconutOptions { ... })Anterior
UseDoconutWebFarm(...) / WebFarmOptionsAnterior
Viewer.DoconutLicense(...) or Viewer.SetLicensePlugin(...)Anterior
viewer.Converter.GetConverter()Anterior
using Doconut.Configs; / using Doconut.Models;Anterior
Manually copied docViewer.js, documentLinks.js, or docViewer.UI.jsAnterior
builder.Services.AddDoconut(...)Actual
app.UseDoconutResources() plus app.UseDoconut() with no argumentsActual
Viewer supplied by dependency injectionActual
await viewer.OpenDocumentAsync(...)Actual

Si ambas columnas aparecen en la misma aplicación, trate la migración como incompleta. No envíe un token de documento a través de recursos o middleware de la otra generación.

Verifique primero el framework host

Esto es una barrera estricta, no una preferencia. El paquete actual tiene como objetivo netstandard2.1:

HostPuede consumir 26.8.0
.NET Core 3.0 o posterior (incluyendo .NET 5/6/7/8)Sí
.NET Framework, cualquier versiónNo

.NET Framework no puede referenciar una biblioteca netstandard2.1. Si la aplicación se ejecuta en .NET Framework, deténgase aquí y use el paquete Doconut.NETFramework en su lugar; a partir de la 26.9.0 requiere .NET Framework 4.7.2. Ambas aplicaciones de referencia para esta versión tienen como objetivo net8.0.

Antes de migrar

  1. Cree una rama y una copia de seguridad desplegable de la aplicación existente.
  2. Registre las versiones exactas de los paquetes core y de complementos.
  3. Inventaríe cada llamada new Viewer(...), llamada InitCache(), llamada de carga de licencia, mapeo UseDoconutWebFarm, controlador de conversión, script Doconut copiado, acción de barra de herramientas personalizada, devolución de llamada del visor y punto final de apertura de documento.
  4. Preserve los archivos .lic actuales y los secretos de despliegue fuera del control de versiones.
  5. Capture un conjunto representativo de documentos PDF, Office, imagen, CAD, correo electrónico, DICOM, buscables, protegidos con contraseña y anotados.
  6. Registre el tiempo de expiración de sesión existente, el comportamiento de seguridad, las fuentes y la configuración de la plataforma.

Migre un entorno antes de cambiar la producción. La integración actual cambia la duración del servicio, el enrutamiento de solicitudes, la propiedad de la sesión, la entrega de recursos al cliente y — si ejecuta una granja — cómo las páginas llegan al navegador.

1. Espacios de nombres: casi todo movido a la raíz

Los tipos de configuración estaban repartidos en cuatro espacios de nombres. Ahora todos están en Doconut.

AntesAhora
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;sin cambios
using Doconut.Middleware;sin cambios

Los nombres de tipo no cambiaron: WordConfig, PdfConfig, ExcelConfig, CssConfig, ScriptConfig, CloudUploadConfig, AzureConfig, CDNConfig, FileShareConfig y el resto sigue allí. En la mayoría de los archivos la edición completa consiste en eliminar dos líneas using.

Doconut.Configs.Editor (BaseConfigEditor, PdfConfigEditor) fue eliminado y no tiene reemplazo en este paquete. Si su aplicación hacía referencia a esos tipos, planifique esa parte por separado y no la trate como parte de esta migración.

2. Compatibilidad de paquetes y licencias

Reemplace o actualice deliberadamente el paquete central; no confíe en que el ID del paquete idéntico seleccione la nueva API. El comando predeterminado instala la última versión estable:

bash
dotnet add package Doconut.NETStandard

Para una migración reproducible a la versión auditada por esta guía, pase la versión como una opción separada:

bash
dotnet add package Doconut.NETStandard --version 26.9.0

Mantenga cada complemento Doconut en la misma versión que el paquete central — Doconut.NETStandard.Converter y Doconut.NETStandard.Dicom. La integración actual carga licencias una sola vez durante AddDoconut(), usando esta precedencia:

text
LicenseStream > LicenseContent > LicensePath > automatic discovery

El descubrimiento automático busca Doconut.Viewer.lic y archivos complementarios Doconut.Viewer.<Capability>.lic. Las llamadas estáticas anteriores Viewer.DoconutLicense(...) y Viewer.SetLicensePlugin(...) no son un mecanismo de inicio actual, y tampoco lo es List<string> de rutas de licencia que aceptaba el antiguo constructor Viewer. Mueva la licencia a DoconutOptions, mantenga los archivos complementarios juntos al usar el descubrimiento automático, reinicie después de cambiar una licencia y verifique las capacidades a través de IDoconutLicenseService.

No asuma que la presencia de una licencia de complemento antigua demuestre derecho para una compilación de complemento actual. Pruebe Viewer, Search, Annotation, Converter y DICOM por separado con los artefactos de la versión aprobada.

3. Inicio e inyección de dependencias

Anteriormente el visor se construía por solicitud y las opciones se pasaban al middleware:

csharp
// Integración previa — solo para contraste; no compile esto con el SDK actual.
var viewer = new Viewer(_cache, _accessor);
// …
appBranch.UseDoconut(new DoconutOptions { UnSafeMode = false, ShowDoconutInfo = false });

La integración actual registra Doconut una sola vez y recibe Viewer mediante inyección de dependencias:

csharp
builder.Services.AddDoconut(options =>
{
    options.UnsafeMode      = false;   // nota el cambio de ortografía: UnSafeMode → UnsafeMode
    options.ShowDoconutInfo = false;
    options.LicensePath     = "Doconut.Viewer.lic";
});
builder.Services.AddDistributedMemoryCache(); // el estado de sesión necesita una caché (MVC/Razor Pages ya añaden una)
builder.Services.AddSession();

app.UseSession();
app.UseDoconutResources();
app.UseDoconut();

Viewer es un servicio transitorio. El gestor de sesión del documento y su caché poseen el estado del documento de mayor duración, no la instancia inyectada particular Viewer.

Tres cosas que debe conservar:

  • new Viewer(cache, accessor) ha desaparecido. Inyecte Doconut.Viewer en su controlador, o use @inject Doconut.Viewer Viewer en una vista Razor.
  • UseDoconutResources() reemplaza el cableado manual app.UseMiddleware<EmbeddedResourceMiddleware>(), y debe ejecutarse antes de la rama del documento.
  • UnSafeMode → UnsafeMode. Un cambio de un solo carácter que el compilador detectará.

Cuando UnsafeMode está false, el SDK valida el token de sesión contra la solicitud originaria, por lo que AddSession() / UseSession() deben seguir presentes en la canalización, UseSession() antes de la rama.

Métodos que ya no existen

AntesAhora
viewer.OpenDocument(path, config, options)await viewer.OpenDocumentAsync(path, config, options)
viewer.InitCache()eliminado — no hay nada que calentar manualmente; elimine la llamada y cualquier bandera de “¿ya inicié?” que la rodee
viewer.ExportToPng(sharedPath)ver §7
viewer.ExportToCloud(cloudConfig)ver §7
using var v = new Viewer(...); v.CloseDocument(t)viewer.CloseDocument(token) en la instancia inyectada

4. Middleware y enrutamiento de recursos

UseDoconut() ahora no recibe argumentos. La forma de la rama MapWhen en sí no necesita cambiar — solo el middleware dentro de ella:

csharp
app.UseDoconutResources();   // ANTES de la rama

app.MapWhen(
    ctx => ctx.Request.Path.Value?.EndsWith("DocImage.axd", StringComparison.OrdinalIgnoreCase) == true,
    branch => branch.UseDoconut());

En la canalización actual:

  1. llame a UseSession() antes de Doconut mientras la seguridad de sesión está habilitada;
  2. llame a UseDoconutResources() antes de UseDoconut();
  3. mantenga ResourcesPath, las URLs de recursos generadas y el cliente ResPath alineados;
  4. mantenga la rama que mapea y el cliente BasePath alineados.

MiddlewarePath es una configuración validada; no crea una rama ASP.NET Core por sí mismo.

5. Construcción y ciclo de vida del visor

Elimine las cachés propiedad de la aplicación de los objetos Viewer. No queda nada en un Viewer que valga la pena conservar: no lleva estado del documento, y la caché de sesión posee todo lo que sobrevive a una solicitud. Inyéctelo en un endpoint, página Razor, controlador o servicio de aplicación con alcance:

csharp
app.MapPost("/api/open", async (Viewer viewer) =>
{
    var token = await viewer.OpenDocumentAsync("wwwroot/files/Sample.pdf");
    return Results.Ok(new { token });
});

El token devuelto identifica una sesión de documento del lado del servidor. Trátelo como una credencial portadora: no lo registre, no lo persista ni lo coloque en analíticas.

6. Apertura y cierre de documentos

Reemplace OpenDocument(...) síncrono con OpenDocumentAsync(...):

csharp
// Integración actual: Viewer proviene de DI y la apertura del documento es asíncrona.
var token = await viewer.OpenDocumentAsync(path, new PdfConfig { AllowSearch = true });

Las sobrecargas actuales aceptan una ruta de archivo o flujo, una configuración de formato opcional, DocOptions opcional y un token de cancelación. Cierre la sesión del servidor explícitamente cuando el navegador ya no la necesite:

csharp
viewer.CloseDocument(token);

Elimine cualquier llamada a InitCache() y la bandera que la protege — no hay nada que calentar manualmente. No reutilice un token generado por la biblioteca anterior después del cambio: abra cada documento nuevamente mediante la API actual.

7. Granja web → distribuida: el mayor cambio

UseDoconutWebFarm y WebFarmOptions ya no existen. Si su aplicación los llama, esta sección es su actualización; si no, pase a §8.

Anteriormente un middleware hacía todo: servía imágenes pre‑renderizadas desde una carpeta compartida, y encuestaba mientras otro nodo aún las escribía.

csharp
// Integración previa — una llamada, coordinación implícita a través del sistema de archivos.
appBranch.UseDoconutWebFarm(new WebFarmOptions
{
    Path                = Path.Combine(env.WebRootPath, "webfarm"),
    PageWaitTimeSeconds = 180,
    StartWaitFromPage   = 5,
});

La misma tarea ahora se divide en dos mitades explícitas. Lado de escritura — el nodo que abre el documento publica todo el conjunto de artefactos (páginas, información del documento, índice de búsqueda, metadatos) en el recurso compartido:

csharp
var result = await _publisher.PublishAsync(          // DistributedDocumentPublisher, inyectado desde DI
    pathToFile,
    new FileShareConfig
    {
        Location              = CloudLocation.FileShare,
        RootPath              = @"\\fileserver\doconut",   // la misma carpeta que usas hoy
        UsePerTokenSubfolders = true,
    },
    config,
    documentOptions,
    new DistributedDocumentPublishOptions
    {
        CleanUpStagingDirectory = true,
        FirstPagePriority       = true,
    });

return Content(result.Token);

Lado de lectura — cualquier nodo sirve desde el recurso compartido:

csharp
app.MapWhen(
    ctx => ctx.Request.Path.Value?.EndsWith("DocImage.axd", StringComparison.OrdinalIgnoreCase) == true,
    branch => branch.UseDoconutCloud<FileShareCloudHandler>(options =>
    {
        options.Location          = CloudLocation.FileShare;
        options.CloudUploadConfig = /* el MISMO FileShareConfig como arriba */;
    }, "/"));
AntesAhora
WebFarmOptions.PathFileShareConfig.RootPath
PageWaitTimeSeconds / StartWaitFromPagedesaparecido — reemplazado por FirstPagePriority en el lado de escritura más FileShareConfig.ReadReadyPollMs en el lado de lectura
viewer.OpenDocument(...) entonces viewer.ExportToPng(share)una llamada PublishAsync(...)
DocOptions.IsWebfarm / WebfarmPathtodavía allí, escrito IsWebFarm / WebFarmPath — pero no necesario en la ruta de publicación

Su topología no cambia. Apunte RootPath al mismo recurso UNC compartido y cada nodo seguirá funcionando como lo hace hoy. Lo que cambia es que la publicación es una operación que usted llama, en lugar de un efecto secundario del renderizado.

Ambas mitades deben coincidir. Si RootPath o UsePerTokenSubfolders difieren entre el publicador y el manejador, el otro nodo responde 404. Construya la configuración en un único ayudante y llámela desde ambos lados.

PageWaitTimeSeconds = 180 significaba "bloquear hasta tres minutos esperando que la página aparezca". El reemplazo es explícito: con FirstPagePriority = true, la página 1 es servible inmediatamente y las páginas posteriores responden HTTP 202 Accepted hasta que se escriban. El visor integrado reintenta automáticamente cuando retryOn409 está configurado. Un cliente que no reintente mostrará mosaicos rotos para páginas que aún se están renderizando.

El arreglo completo, incluyendo la publicación en segundo plano y los tickets de acceso, está en Despliegues Distribuidos.

8. La conversión es un complemento, y mucho más pequeño

Registre el complemento, luego inyecte la fachada DocumentConverter:

csharp
builder.Services.AddDoconut(o => o.AddPlugin<ConverterPlugin>());
csharp
// Integración anterior
var converter = viewer.Converter.GetConverter();
var config    = new WordConfigConverter { TargetFormat = WordConfigConverter.EnTargetFormat.PDF };
var result    = converter.Convert(stream, SourceFormatConverter.DOCX, config);

// Integración actual
var result = await _converter.ConvertAsync(stream, ".docx", ConversionTarget.Pdf, null, ct);

Lo que eso reemplaza:

  • SourceFormatConverter — eliminado. Pase la extensión del archivo como una cadena, con el punto incluido.
  • Los tipos *ConfigConverter por familia (WordConfigConverter, ExcelConfigConverter, …), cada uno con un enum EnTargetFormat anidado — eliminado. Ahora hay un enum ConversionTarget para cada familia.
  • viewer.Converter.GetConverter() — eliminado. Inyecte Doconut.DocumentConverter.

ConvertAsync devuelve un flujo buscable, por lo que return File(result, mime, name) funciona directamente — la copia MemoryStream del código antiguo ya no es necesaria. En el ejemplo incluido, esto eliminó un conmutador de extensión de 68 casos y diez controladores casi idénticos.

Vea Complemento Convertidor para la funcionalidad completa.

9. Proveedores de nube

UseDoconutCloud se volvió genérico. El proveedor es el argumento de tipo en lugar de un valor Location evaluado dentro del middleware:

csharp
// Integración anterior
appBranch.UseDoconutCloud(new CloudOptions { Location = CloudLocation.CDN, ... });

// Integración actual
branch.UseDoconutCloud<CDNCloudHandler>(options =>
{
    options.Location          = CloudLocation.CDN;
    options.CloudUploadConfig = new CDNConfig { DoconutCdnUrl = "..." };
}, "/");

Las clases de configuración no han cambiado, salvo el espacio de nombres (Doconut.Configs.Cloud → Doconut.Clouds): AzureConfig, AmazonConfig, GoogleCloudConfig, DropBoxConfig, RedisConfig, CDNConfig, FTPConfig, y el nuevo FileShareConfig. Los manejadores se llaman <Provider>CloudHandler.

El manejador CDN es solo lectura — sirve lo que ya está en el CDN; no sube nada.

10. Objetos de configuración que cambiaron de nombre

AntesAhora
DoconutOptions.UnSafeModeUnsafeMode
DocOptions.IsWebfarmIsWebFarm
DocOptions.WebfarmPathWebFarmPath
DocOptions.ImageResolutiontodavía presente pero obsoleta — establezca la resolución en la configuración de formato en su lugar

DocOptions también obtiene IsSecured.

La API actual también separa las preocupaciones de forma más estricta que la anterior, así que verifique que cada configuración esté en el objeto que ahora la posee:

PreocupaciónTipo actual
Rutas de middleware, licencias, registro de complementosDoconutOptions
Contraseña, tiempo de espera, seguridad, marca de aguaDocOptions
Renderizado de formato y DPIPdfConfig, WordConfig, ExcelConfig, y otros tipos BaseConfig
Valores predeterminados del widget del navegadorViewerConfig o las opciones equivalentes de JavaScript
CSS y scripts generadosCssConfig y ScriptConfig
Almacenamiento compartido y proveedores de nubeFileShareConfig y las otras configuraciones Doconut.Clouds

No continúe usando DocOptions.ImageResolution como control de renderizado. Está obsoleto; establezca BaseConfig.ImageResolution en la configuración específica del formato. Revise todas las configuraciones predeterminadas en lugar de asumir que una configuración anterior tiene el mismo comportamiento.

11. El visor del lado del cliente — dos cambios que fallan SILENCIOSAMENTE

Ambas cosas dejan el servidor funcionando perfectamente. Su documento se renderiza, la página se ve bien y no aparece nada en la consola del navegador. Lea esta sección incluso si su C# compila al primer intento.

Los callbacks del visor son opciones ahora, no funciones globales

El visor anterior llamaba a sus manejadores por nombre, derivando el nombre de la función global del id del contenedor. Declarar function ctlDoc_OnViewerReady() en una página con <div id="div_ctlDoc"> era suficiente. El visor actual toma callbacks explícitos en el objeto de opciones y ya no busca esas funciones globales:

javascript
objctlDoc = $("#div_ctlDoc").docViewer({
    // ... sus opciones existentes ...
    onViewerBusy:     ctlDoc_OnViewerBusy,      // se encontró por nombre
    onViewerReady:    ctlDoc_OnViewerReady,     // se encontró por nombre
    onCopy:           ctlDoc_Copy,              // fue ctlDoc_Copy(text)
    onAutoLoadStatus: ctlDoc_AutoLoadStatus     // fue ctlDoc_AutoLoadStatus(page)
});

Por qué esto es problemático: la llamada anterior estaba envuelta en un catch vacío, que absorbía todo. Ahora sus funciones simplemente nunca se ejecutan y nada informa un error. El síntoma habitual es un spinner activo que nunca se detiene — porque la función que lo ocultaba era ctlDoc_OnViewerReady. El documento detrás de él está bien.

La lista completa de opciones es onPageLoading, onPageLoaded, onThumbnailClicked, onPageClicked, onDoubleClick, onViewerBusy, onViewerReady, onViewerError, onCopy, onAnnSaved, onAnnSaveError, onAnnLoaded, onAnnClosed, onAutoLoadStatus, onThumbsShown, y onError. No hay callback de clic en enlaces: el manejo de hipervínculos está incorporado, impulsado por showHyperlinks.

ResPath debe apuntar al prefijo del recurso

javascript
ResPath: '',                      // ANTES — los recursos provenían de la raíz de la aplicación
ResPath: 'doconut-res/images',    // AHORA    — el prefijo UseDoconutResources() monta

Si cambiaste el prefijo mediante DoconutOptions.ResourcesPath, usa ese valor en su lugar.

12. Barra de herramientas del visor, búsqueda y anotación

No migres los scripts antiguos uno por uno. Las aplicaciones de referencia actuales componen un paquete de página completo:

  1. emitir el CSS del Visor y el CSS con licencia de Búsqueda/Anotación con ReferenceCss;
  2. renderizar la barra de herramientas del Visor propiedad de la aplicación;
  3. renderizar searchBarMount, annBarMount y el montaje del Visor requerido;
  4. emitir los scripts del Visor y del módulo con licencia con ReferenceScripts;
  5. cargar el script auxiliar de la barra de herramientas propio de la aplicación;
  6. inicializar un objViewer;
  7. inicializar las cintas de Búsqueda y Anotación con licencia;
  8. llamar a attach(objViewer) en cada cinta;
  9. abrir el documento y llamar a objViewer.View(token).

Búsqueda y Anotación son módulos adjuntos al mismo Visor, no barras de herramientas independientes.
La barra de herramientas principal pertenece a la aplicación anfitriona; las cintas de Búsqueda y Anotación son recursos incrustados, con acceso controlado por capacidades.

Elimina los archivos copiados manualmente como documentLinks.js y docViewer.UI.js solo después de que la página actual funcione con los recursos emitidos por ReferenceCss y ReferenceScripts.

13. Registro de plugins

Los métodos estáticos de licencia de plugins no registran los plugins actuales. Instala y registra cada paquete lanzado explícitamente:

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

AddDoconut() valida las capacidades de plugins registradas al iniciar. Converter y DICOM son los plugins .NET Standard lanzados. Búsqueda y Anotación normales son funciones incorporadas con licencia, no paquetes AddPlugin<TPlugin>().

14. Seguridad de sesión y documento

La integración actual vincula documentos a tokens opacos y sesiones en caché. Con el UnsafeMode = false predeterminado, UseDoconut() agrega seguridad de acceso a documentos y el anfitrión debe configurar la sesión ASP.NET:

csharp
builder.Services.AddDistributedMemoryCache(); // el estado de sesión necesita una caché (MVC/Razor Pages ya añaden una)
builder.Services.AddSession();
app.UseSession();

Mantén DocOptions.IsSecured = true a menos que un diseño revisado requiera lo contrario. Nunca uses UnsafeMode = true como atajo de migración en un solo nodo. Prueba solicitudes sin token, con token malformado, token expirado y un token de una sesión de navegador diferente.

En una granja, la solicitud de página puede llegar a un nodo que nunca vio la solicitud inicial, por lo que la verificación por sesión la rechazaría. Ese es el único caso en que UnsafeMode = true es correcto — y debe combinarse con tickets de acceso firmados a través de AddDoconutDistributedDocumentSecurity, no enviados por sí solo. Ver Despliegues Distribuidos.

Nota de nomenclatura

En todos los frameworks la clase es Viewer. Si encuentras DocumentViewer en fragmentos antiguos o artículos de terceros, ese tipo nunca existió en el SDK.

15. Orden sugerido de trabajo

  1. Confirma que el framework anfitrión pueda consumir netstandard2.1. Si no puede, detente.
  2. Actualiza el paquete a 26.8.0 y compila. Resuelve los errores de compilación — la mayoría son las líneas using en §1.
  3. Mueve el inicio a AddDoconut() y las llamadas al middleware a su nuevo orden (§3, §4).
  4. Inyecta Viewer donde lo estabas construyendo, haz OpenDocument asíncrono y elimina InitCache() (§5, §6).
  5. Si utilizas la granja web, haz §7 — la única parte que es un rediseño en lugar de un renombrado.
  6. Si conviertes documentos, haz §8.
  7. Haz §11 — los cambios del lado del cliente. Son los que no se anunciarán por sí mismos.
  8. Abre un documento real en un navegador y observa el indicador de carga. Una compilación verde no prueba nada aquí: la licencia, el registro de plugins, la ruta del recurso y las devoluciones de llamada del visor fallan solo en tiempo de ejecución. Para una granja, verifica que un documento publicado por un nodo sea servido por otro.

Probando la migración

Como mínimo, verificar:

  • inicio de la aplicación con la licencia de producción y cada plugin registrado;
  • CSS/scripts del visor y todas las solicitudes de página-imagen bajo las rutas elegidas;
  • apertura de documento, navegación, zoom, miniaturas, impresión y cierre explícito;
  • Búsqueda en un documento con texto y el estado no buscable de un archivo solo de imagen;
  • carga, guardado, exportación de anotaciones y control de capacidades;
  • descubrimiento del objetivo del conversor, salida, descarga y estado de la marca de agua;
  • páginas, fotogramas y animación DICOM; los metadatos técnicos no están disponibles en este paquete;
  • documentos protegidos con contraseña, fuentes personalizadas, texto no latino y tiempos de espera configurados;
  • rechazo de token entre sesiones y comportamiento de sesión expirada;
  • para una granja: publicar en un nodo, solicitar una página tardía desde otro, y confirmar que el visor reintenta respuestas 202 en lugar de mostrar mosaicos rotos;
  • móvil, modo oscuro y la ruta del proxy inverso de producción.

Plan de reversión

Mantenga el artefacto de despliegue anterior, los paquetes coincidentes, los archivos de licencia y los recursos del navegador copiados juntos. Una reversión segura cambia toda la generación de la aplicación; no mezcla un servidor de generación anterior con los scripts actuales, ni un servidor actual con los sitios de llamada new Viewer(...).

Antes del cambio, documente:

  • la ranura de despliegue o artefacto usado para la reversión;
  • el impacto del almacenamiento compartido, si lo hay — los artefactos publicados por 26.8.0 no son consumidos por el middleware de la granja web anterior;
  • cómo se invalidarán las sesiones de documento activas;
  • la verificación de salud y el documento de prueba usado para decidir la reversión;
  • quién puede restaurar el conjunto de paquetes y la configuración anteriores.

Documentación heredada

El manual traducido anterior sigue disponible en Configuración heredada de .NET Standard. La Pasarela de integración anterior explica las mismas señales de identificación y enlaza de nuevo a esta guía de migración.

Mantenga la URL histórica en marcadores y tickets de soporte mientras las instalaciones netstandard2.0 aún existan. Documenta una generación diferente y no se redirige a la API actual.

¿Fue útil esta página?