Introducción al marco de compatibilidad de paquete

El Marco de compatibilidad de paquete es un kit de código abierto que te permite aplicar correcciones a tu aplicación de escritorio existente (sin modificar el código), de modo que pueda ejecutarse en un contenedor de MSIX. La plataforma de compatibilidad de paquete te ayuda a que la aplicación siga las prácticas recomendadas del entorno de tiempo de ejecución moderno.

En este artículo se proporciona un vistazo detallado a cada componente del marco de compatibilidad de paquetes y una guía paso a paso para usarlo.

Descripción de lo que está dentro de un marco de compatibilidad de paquetes

La plataforma de compatibilidad de paquete contiene un archivo ejecutable, un archivo DLL del administrador de tiempo de ejecución y un conjunto de correcciones de tiempo de ejecución.

Este es el proceso:

1. Creas un archivo de configuración que especifique las correcciones que desees aplicar a la aplicación.
2. Modificas el paquete para que apunte al archivo ejecutable del iniciador de la plataforma de compatibilidad de paquete (PSF).

Cuando los usuarios abren la aplicación, el iniciador de la plataforma de compatibilidad de paquete es el primer ejecutable que se ejecuta. Lee el archivo de configuración e inserta las correcciones de tiempo de ejecución y el archivo DLL del administrador de tiempo de ejecución en el proceso de la aplicación. El administrador de tiempo de ejecución aplica la corrección cuando sea necesario para que la aplicación se ejecute dentro de un contenedor de MSIX.

Paso 1: Identificación de problemas de compatibilidad de aplicaciones empaquetadas

Primero, creas un paquete NuGet para la aplicación. A continuación, instálalo, ejecútalo y observa su comportamiento. Es posible que recibas mensajes de error que te pueden ayudar a identificar un problema de compatibilidad. También puedes utilizar Process Monitor para identificar problemas. Los problemas comunes se relacionan con las suposiciones de la aplicación con respecto a los permisos de directorio de trabajo y ruta de acceso del programa.

Uso del Monitor de procesos para identificar un problema

El Monitor de procesos es una utilidad eficaz para observar las operaciones de archivo y registro de una aplicación y sus resultados. Esto puede ayudarte a comprender los problemas de compatibilidad de aplicaciones. Después de abrir el Monitor de procesos, agrega un filtro (Filtro > Filtro...) para incluir solo los eventos del ejecutable de la aplicación.

Aparecerá una lista de eventos. Para muchos de estos eventos, la palabra SUCCESS aparecerá en la columna Resultado.

Opcionalmente, puedes filtrar eventos para mostrar solo los errores.

Si sospechas un error de acceso al sistema de archivos, busca eventos con errores que se encuentran en System32/SysWOW64 o en la ruta de acceso del archivo de paquete. Los filtros también pueden ayudar aquí. Comienza en la parte inferior de esta lista y desplázate hacia arriba. Los errores que aparecen en la parte inferior de esta lista se han producido más recientemente. Presta más atención a los errores que contienen cadenas como "acceso denegado" y "ruta de acceso/nombre no encontrado" y omite las cosas que no parezcan sospechosas. El PSFSample tiene dos problemas. Puedes ver esos problemas en la lista que aparece en la siguiente imagen.

En el primer problema que aparece en esta imagen, la aplicación no puede leer del archivo "Config.txt" que se encuentra en la ruta de acceso "C:\Windows\SysWOW64". Es poco probable que la aplicación intente hacer referencia a esa ruta de acceso directamente. Lo más probable es que intente leer desde ese archivo mediante una ruta de acceso relativa y, de forma predeterminada, "System32/SysWOW64" es el directorio de trabajo de la aplicación. Esto sugiere que la aplicación espera que su directorio de trabajo actual se establezca en algún lugar del paquete. Al buscar dentro de appx, podemos ver que el archivo existe en el mismo directorio que el ejecutable.

El segundo problema aparece en la imagen siguiente.

En este problema, la aplicación no puede escribir un archivo .log en su ruta de acceso del paquete. Esto sugeriría que una corrección de redirección de archivos podría ayudar.

Paso 2: Búsqueda de una corrección en tiempo de ejecución

El PSF contiene correcciones en tiempo de ejecución que puedes usar en este momento, como la corrección de redirección de archivos.

Corrección de redireccionamiento de archivos

Puedes usar la Corrección de redireccionamiento de archivos para redirigir los intentos de escritura o lectura de datos en un directorio al que no se puede acceder desde una aplicación que se ejecuta en un contenedor MSIX.

Por ejemplo, si la aplicación escribe en un archivo de registro que se encuentra en el mismo directorio que el ejecutable de las aplicaciones, puedes usar la Corrección de redireccionamiento de archivos para crear ese archivo de registro en otra ubicación, como el almacén de datos de la aplicación local.

Correcciones en tiempo de ejecución de la comunidad

Asegúrate de revisar las contribuciones de la comunidad a nuestra página de GitHub. Es posible que otros desarrolladores hayan resuelto un problema similar al tuyo y han compartido una corrección en tiempo de ejecución.

Paso 3: Aplicación de una corrección en tiempo de ejecución

Puedes aplicar una corrección en tiempo de ejecución existente con algunas herramientas sencillas de Windows SDK y siguiendo estos pasos.

• Crea una carpeta de diseño de paquete
• Obtén los archivos del marco de compatibilidad de paquete
• Agrégalos al paquete
• Modifica el manifiesto del paquete
• Creación de un archivo de configuración

Vamos a examinar cada tarea.

Creación de la carpeta de diseño de paquete

Si ya tienes un archivo .msix (o .appx), puedes desempaquetar su contenido en una carpeta de diseño que servirá como área de almacenamiento provisional para el paquete. Puedes hacerlo desde un símbolo del sistema mediante la herramienta MakeAppx. en función de la ruta de instalación del SDK, aquí es donde encontrarás la herramienta makeappx.exe en tu PC Windows 10: x86: C:\Archivos de programa (x86)\Windows Kits\10\bin\x86\makeappx.exe x64: C:\Archivos de programa (x86)\Windows Kits\10\bin\x64\makeappx.exe

makeappx unpack /p PSFSamplePackage_1.0.60.0_AnyCPU_Debug.msix /d PackageContents

Esto te dará algo similar a lo siguiente.

Si no tienes un archivo .msix (o .appx) para empezar, puedes crear la carpeta del paquete y los archivos desde cero.

Obtén los archivos del marco de compatibilidad de paquete

Puedes obtener el paquete Nuget de PSF mediante la herramienta de línea de comandos Nuget independiente o a través de Visual Studio.

Obtención del paquete utilizando la herramienta de línea de comandos

Instala la herramienta de línea de comandos Nuget desde esta ubicación: https://www.nuget.org/downloads. A continuación, desde la línea de comandos de Nuget, ejecuta este comando:

nuget install Microsoft.PackageSupportFramework

Como alternativa, puedes cambiar el nombre de la extensión de paquete a .zip y descomprimirla. Todos los archivos que necesitas estarán en la carpeta /bin.

Obtención del paquete con Visual Studio

En Visual Studio, haz clic con el botón derecho del ratón en el nodo de tu solución o proyecto y elige uno de los comandos de administración de paquetes Nuget. Busca Microsoft.PackageSupportFramework o PSF para encontrar el paquete en Nuget.org. A continuación, instálalo.

Adición de los archivos del marco de compatibilidad de paquetes al paquete

Agrega los archivos DLL de PSF de 32 y 64 bits y archivos ejecutables necesarios al directorio del paquete. Usa la siguiente tabla como guía. También querrás incluir las correcciones en tiempo de ejecución que necesites. En nuestro ejemplo, necesitamos la corrección en tiempo de ejecución de redirección de archivos.

El ejecutable de la aplicación es x64	El ejecutable de la aplicación es x86
PSFLauncher64.exe	PSFLauncher32.exe
PSFRuntime64.dll	PSFRuntime32.dll
PSFRunDll64.exe	PSFRunDll32.exe

El contenido del paquete ahora deberá ser similar a esto.

Modifica el manifiesto del paquete

Abre el manifiesto del paquete en un editor de texto y, a continuación, establece el atributo Executable del elemento Application en el nombre del archivo ejecutable iniciador de PSF. Si conoces la arquitectura de la aplicación de destino, selecciona la versión adecuada, PSFLauncher32.exe o PSFLauncher64.exe. Si no es así, PSFLauncher32.exe funcionará en todos los casos. Este es un ejemplo.

<Package ...>
  ...
  <Applications>
    <Application Id="PSFSample"
                 Executable="PSFLauncher32.exe"
                 EntryPoint="Windows.FullTrustApplication">
      ...
    </Application>
  </Applications>
</Package>

Creación de un archivo de configuración

Crea un nombre de archivo config.json y guarda ese archivo en la carpeta raíz del paquete. Modifica el identificador de aplicación declarado del archivo config.json para que apunte al archivo ejecutable que acabas de reemplazar. Con el conocimiento que obtuviste del uso del Monitor de procesos, también puedes establecer el directorio de trabajo, así como usar la corrección de redirección de archivos para redirigir lecturas y escrituras a archivos .log en el directorio relativo al paquete "PSFSampleApp".

{
    "applications": [
        {
            "id": "PSFSample",
            "executable": "PSFSampleApp/PSFSample.exe",
            "workingDirectory": "PSFSampleApp/"
        }
    ],
    "processes": [
        {
            "executable": "PSFSample",
            "fixups": [
                {
                    "dll": "FileRedirectionFixup.dll",
                    "config": {
                        "redirectedPaths": {
                            "packageRelative": [
                                {
                                    "base": "PSFSampleApp/",
                                    "patterns": [
                                        ".*\\.log"
                                    ]
                                }
                            ]
                        }
                    }
                }
            ]
        }
    ]
}

A continuación se muestra una guía para el esquema config.json:

Matriz	key	Value
applications	id	Usa el valor del atributo Id del elemento Application en el manifiesto de paquete.
applications	ejecutable	Ruta de acceso relativa al paquete al archivo ejecutable que deseas iniciar. En la mayoría de los casos, puedes obtener este valor del archivo de manifiesto de paquete antes de modificarlo. Es el valor del atributo Executable del elemento Application.
applications	workingDirectory	(Opcional) Ruta de acceso relativa al paquete que se va a usar como directorio de trabajo de la aplicación que se inicia. Si no establece este valor, el sistema operativo usa el directorio System32 como directorio de trabajo de la aplicación.
procesos	ejecutable	En la mayoría de los casos, este será el nombre del executable configurado anteriormente con la ruta de acceso y la extensión de archivo quitadas.
correcciones	dll	Ruta de acceso relativa al paquete a la corrección, .msix/.appx que se va a cargar.
correcciones	config	(Opcional) Controla cómo se comporta el archivo dll de corrección. El formato exacto de este valor varía según la corrección, ya que cada corrección puede interpretar este "blob" como quiera.

Las claves applications, processes y fixups son matrices. Esto significa que puedes usar el archivo config.json para especificar más de una aplicación, proceso y archivo DLL de corrección.

Empaquetado y prueba de la aplicación

Después, cree un paquete.

makeappx pack /d PackageContents /p PSFSamplePackageFixup.msix

A continuación, fírmelo.

signtool sign /a /v /fd sha256 /f ExportedSigningCertificate.pfx PSFSamplePackageFixup.msix

Para obtener más información, consulte cómo crear un certificado de firma de paquete y cómo firmar un paquete mediante SignTool

Con PowerShell, instala el paquete.

Nota:

Recuerda desinstalar primero el paquete.

powershell Add-AppPackage .\PSFSamplePackageFixup.msix

Ejecuta la aplicación y observa el comportamiento con la corrección en tiempo de ejecución aplicada. Repite los pasos de diagnóstico y empaquetado según sea necesario.

Comprueba si el marco de compatibilidad de paquetes se está ejecutando

Puedes comprobar si se está ejecutando la corrección en tiempo de ejecución. Una manera de hacerlo es abrir el Administrador de tareas y hacer clic en Más detalles. Busca la aplicación a la que se aplicó el marco de compatibilidad de paquetes y expande los detalles de la aplicación para obtener más detalles. Deberías poder ver que se está ejecutando el marco de compatibilidad del paquete.

Uso de la corrección de seguimiento

Una técnica alternativa para diagnosticar problemas de compatibilidad de aplicaciones empaquetadas es usar la corrección de seguimiento. Este archivo DLL se incluye con el PSF y proporciona una vista de diagnóstico detallada del comportamiento de la aplicación, similar al monitor de procesos. Está especialmente diseñado para revelar problemas de compatibilidad de aplicaciones. Para usar la corrección de seguimiento, agrega el archivo DLL al paquete, agrega el siguiente fragmento a config.json y, a continuación, empaqueta e instala la aplicación.

{
    "dll": "TraceFixup.dll",
    "config": {
        "traceLevels": {
            "filesystem": "allFailures"
        }
    }
}

De forma predeterminada, la corrección de seguimiento filtra los errores que podrían considerarse "esperados". Por ejemplo, las aplicaciones podrían intentar eliminar incondicionalmente un archivo sin comprobar si ya existe, ignorando el resultado. Esto tiene la consecuencia desafortunada de que algunos errores inesperados podrían filtrarse, por lo que en el ejemplo anterior, optamos por recibir todos los errores de las funciones del sistema de archivos. Lo hacemos porque sabemos desde antes de que se produzca un error en el intento de lectura del archivo Config.txt con el mensaje "archivo no encontrado". Se trata de un error que se observa con frecuencia y que generalmente no se supone que es inesperado. En la práctica, es mejor que empieces a filtrar solo a errores inesperados y, a continuación, revertir a todos los errores si hay un problema que todavía no se puede identificar.

De forma predeterminada, la salida de la corrección de seguimiento se envía al depurador asociado. En este ejemplo, no vamos a adjuntar un depurador y, en su lugar, usaremos el programa DebugView de SysInternals para ver su salida. Después de ejecutar la aplicación, podemos ver los mismos errores que antes, lo que nos apuntaría hacia las mismas correcciones en tiempo de ejecución.

Depuración, ampliación o creación de una corrección en tiempo de ejecución

Puedes usar Visual Studio para depurar una corrección en tiempo de ejecución, ampliar una corrección en tiempo de ejecución o crear una desde cero. Tendrás que hacer estas cosas para tener éxito.

• Adición de un proyecto de empaquetado
• Adición del proyecto para la corrección en tiempo de ejecución
• Adición de un proyecto que inicia el archivo ejecutable del iniciador de PSF
• Configuración del proyecto de empaquetado

Cuando hayas terminado, tu solución debe tener este aspecto.

Echemos un vistazo a cada proyecto de este ejemplo.

Proyecto	Propósito
DesktopApplicationPackage	Este proyecto se basa en el Proyecto de paquete de aplicación de Windows y genera el paquete MSIX.
Runtimefix	Se trata de un proyecto de biblioteca de vínculos dinámicos de C++ que contiene una o varias funciones de reemplazo que actúan como corrección en tiempo de ejecución.
PSFLauncher	Este es el proyecto vacío de C++. Este proyecto es un lugar para recopilar los archivos distribuibles en tiempo de ejecución del marco de compatibilidad de paquetes. Genera un archivo ejecutable. Ese ejecutable es lo primero que se ejecuta cuando se inicia la solución.
WinFormsDesktopApplication	Este proyecto contiene el código fuente de una aplicación de escritorio.

Para ver un ejemplo completo que contiene todos estos tipos de proyectos, consulta PSFSample.

Veamos los pasos para crear y configurar cada uno de estos proyectos en la solución.

Creación de una solución de paquete

Si aún no tienes una solución para la aplicación de escritorio, crea una nueva solución en blanco en Visual Studio.

También puedes agregar cualquier proyecto de aplicación que tengas.

Adición de un proyecto de empaquetado

Si aún no tienes un Proyecto de paquete de aplicación de Windows , crea uno y agrégalo a la solución.

Para obtener más información sobre el Proyecto de paquete de aplicación de Windows, consulta Empaquetado de la aplicación mediante Visual Studio.

En el Explorador de soluciones, haz clic con el botón derecho en el proyecto de empaquetado, selecciona Editar y, a continuación, añade esto al final del archivo del proyecto:

<Target Name="PSFRemoveSourceProject" AfterTargets="ExpandProjectReferences" BeforeTargets="_ConvertItems">
<ItemGroup>
  <FilteredNonWapProjProjectOutput Include="@(_FilteredNonWapProjProjectOutput)">
  <SourceProject Condition="'%(_FilteredNonWapProjProjectOutput.SourceProject)'=='<your runtime fix project name goes here>'" />
  </FilteredNonWapProjProjectOutput>
  <_FilteredNonWapProjProjectOutput Remove="@(_FilteredNonWapProjProjectOutput)" />
  <_FilteredNonWapProjProjectOutput Include="@(FilteredNonWapProjProjectOutput)" />
</ItemGroup>
</Target>

Adición del proyecto para la corrección en tiempo de ejecución

Agregue un proyecto de Biblioteca de vínculos dinámicos (DLL) de C++ a la solución.

Haz clic con el botón derecho en el proyecto y selecciona Propiedades.

En las páginas de propiedades, busca el campo Estándar de lenguaje C++ y, a continuación, en la lista desplegable situada junto a ese campo, selecciona la opción Estándar ISO C++17 (/std:c++17).

Haz clic con el botón derecho en ese proyecto y, a continuación, en el menú contextual, elige la opción Administrar paquetes Nuget. Asegúrate de que la opción Origen del paquete está establecida en Todos o nuget.org.

Haz clic en el icono de configuración situado junto a ese campo.

Busca el paquete Nuget de PSF* y, a continuación, instálalo para este proyecto.

Si deseas depurar o ampliar una corrección en tiempo de ejecución existente, agrega los archivos de corrección en tiempo de ejecución que obtuviste mediante las instrucciones descritas en la sección Búsqueda de una corrección en tiempo de ejecución de esta guía.

Si piensas crear una nueva corrección, no agregues nada a este proyecto todavía. Te ayudaremos a agregar los archivos adecuados a este proyecto más adelante en esta guía. Por ahora, continuaremos configurando la solución.

Adición de un proyecto que inicia el archivo ejecutable del iniciador de PSF

Agrega un proyecto vacío de C++ a la solución.

Agrega el paquete Nuget de PSF a este proyecto mediante las mismas instrucciones descritas en la sección anterior.

Abre las páginas de propiedades del proyecto y, en la página de configuración General, establece la propiedad Nombre de destino en PSFLauncher32 o PSFLauncher64, en función de la arquitectura de la aplicación.

Agrega una referencia de proyecto al proyecto de corrección en tiempo de ejecución de la solución.

Haz clic con el botón derecho en la referencia y, a continuación, en la ventana Propiedades, aplica estos valores.

Propiedad	Valor
Copia local	True
Copiar ensamblados satélite locales	True
Salida de ensamblado de referencia	True
Dependencias de la biblioteca de vínculos	False
Vincular entradas de dependencia de biblioteca	False

Configuración del proyecto de empaquetado

En el proyecto de empaquetado, haz clic con el botón derecho en la carpeta Aplicaciones y elige Agregar referencia.

Elige el proyecto de iniciador de PSF y el proyecto de aplicación de escritorio, después, selecciona el botón Aceptar.

Nota:

Si no tienes el código fuente en la aplicación, simplemente elige el proyecto de Iniciador de PSF. Te mostraremos cómo hacer referencia al archivo ejecutable al crear un archivo de configuración.

En el nodo Aplicaciones, haz clic con el botón derecho en la aplicación Iniciador de PSF y, a continuación, elige Establecer como punto de entrada.

Agrega un archivo denominado config.json al proyecto de empaquetado y, a continuación, copia y pega el siguiente texto json en el archivo. Establece la propiedad Package Action en Contenido.

{
    "applications": [
        {
            "id": "",
            "executable": "",
            "workingDirectory": ""
        }
    ],
    "processes": [
        {
            "executable": "",
            "fixups": [
                {
                    "dll": "",
                    "config": {
                    }
                }
            ]
        }
    ]
}

Proporciona un valor para cada clave. Use esta tabla como guía.

Matriz	key	Value
applications	id	Usa el valor del atributo Id del elemento Application en el manifiesto de paquete.
applications	ejecutable	Ruta de acceso relativa al paquete al archivo ejecutable que deseas iniciar. En la mayoría de los casos, puedes obtener este valor del archivo de manifiesto de paquete antes de modificarlo. Es el valor del atributo Executable del elemento Application.
applications	workingDirectory	(Opcional) Ruta de acceso relativa al paquete que se va a usar como directorio de trabajo de la aplicación que se inicia. Si no establece este valor, el sistema operativo usa el directorio System32 como directorio de trabajo de la aplicación.
procesos	ejecutable	En la mayoría de los casos, este será el nombre del executable configurado anteriormente con la ruta de acceso y la extensión de archivo quitadas.
correcciones	dll	Ruta de acceso relativa al paquete al archivo DLL de corrección que se va a cargar.
correcciones	config	(Opcional) Controla cómo se comporta el archivo DLL de corrección. El formato exacto de este valor varía según la corrección, ya que cada corrección puede interpretar este "blob" como quiera.

Cuando hayas terminado, el archivo config.json tendrá un aspecto similar al siguiente.

{
  "applications": [
    {
      "id": "DesktopApplication",
      "executable": "DesktopApplication/WinFormsDesktopApplication.exe",
      "workingDirectory": "WinFormsDesktopApplication"
    }
  ],
  "processes": [
    {
      "executable": ".*App.*",
      "fixups": [ { "dll": "RuntimeFix.dll" } ]
    }
  ]
}

Nota:

Las claves applications, processes y fixups son matrices. Esto significa que puedes usar el archivo config.json para especificar más de una aplicación, proceso y archivo DLL de corrección.

Depuración de una corrección en tiempo de ejecución

En Visual Studio, pulsa F5 para iniciar el depurador. Lo primero que se inicia es la aplicación de Iniciador de PSF, que a su vez inicia la aplicación de escritorio de destino. Para depurar la aplicación de escritorio de destino, tendrás que asociarla manualmente al proceso de aplicación de escritorio seleccionando Depurar->Asociar al proceso y, a continuación, seleccionando el proceso de aplicación. Para permitir la depuración de una aplicación .NET con un archivo DLL de corrección en tiempo de ejecución nativo, selecciona tipos de código administrados y nativos (depuración en modo mixto).

Una vez configurado esto, puedes establecer puntos de interrupción junto a líneas de código en el código de la aplicación de escritorio y el proyecto de corrección en tiempo de ejecución. Si no tienes el código fuente en la aplicación, podrás establecer puntos de interrupción solo junto a líneas de código en el proyecto de corrección en tiempo de ejecución.

Dado que la depuración F5 ejecuta la aplicación mediante la implementación de archivos sueltos desde la ruta de acceso de la carpeta de diseño del paquete, en lugar de instalar desde un paquete .msix/.appx, la carpeta de diseño normalmente no tiene las mismas restricciones de seguridad que una carpeta de paquete instalada. Como resultado, es posible que no sea posible reproducir errores de denegación de acceso a la ruta de acceso del paquete antes de aplicar una corrección en tiempo de ejecución.

Para solucionar este problema, usa la implementación del paquete .msix / .appx en lugar de la implementación de archivos flexible de F5. Para crear un archivo de paquete .msix / .appx, usa la utilidad MakeAppx desde Windows SDK, como se ha descrito anteriormente. O bien, desde Visual Studio, haz clic con el botón derecho en el nodo del proyecto de aplicación y selecciona Store:> Crear paquetes de aplicaciones.

Otro problema con Visual Studio es que no tiene compatibilidad integrada para asociarse a ningún proceso secundario iniciado por el depurador. Esto dificulta la depuración de la lógica en la ruta de inicio de la aplicación de destino, que Visual Studio debe asociar manualmente después del inicio.

Para solucionar este problema, usa un depurador que admita la asociación de procesos secundarios. Ten en cuenta que, por lo general, no es posible adjuntar un depurador Just-In-Time (JIT) a la aplicación de destino. Esto se debe a que la mayoría de las técnicas JIT implican iniciar el depurador en lugar de la aplicación de destino, a través de la clave del Registro ImageFileExecutionOptions. Esto contraviene el mecanismo de desvío usado por PSFLauncher.exe para insertar FixupRuntime.dll en la aplicación de destino. WinDbg, incluido en las herramientas de depuración para Windows y obtenido de Windows SDK, admite la asociación de procesos secundarios. Ahora también admite directamente el inicio y la depuración de una aplicación para UWP.

Para depurar el inicio de la aplicación de destino como un proceso secundario, inicia WinDbg.

windbg.exe -plmPackage PSFSampleWithFixup_1.0.59.0_x86__7s220nvg1hg3m -plmApp PSFSample

En el símbolo del sistema WinDbg, habilita la depuración secundaria y establece los puntos de interrupción adecuados.

.childdbg 1
g

(ejecutar hasta que se inicie la aplicación de destino y se divida en el depurador)

sxe ld fixup.dll
g

(ejecutar hasta que se cargue el archivo DLL de corrección)

bp ...

Nota:

PLMDebug también se puede usar para adjuntar un depurador a una aplicación al iniciarse y también se incluye en las Herramientas de depuración para Windows. Sin embargo, es más complejo usar que la compatibilidad directa que ahora proporciona WinDbg.

Soporte técnico

¿Tienes alguna pregunta? Haznos una pregunta en el espacio de conversación del marco de compatibilidad de paquetes en el sitio de la comunidad de la tecnología MSIX.