Introducción al marco de soporte técnico de paquetes

El marco de soporte técnico de paquetes es un kit de código abierto que le ayuda a aplicar correcciones a la aplicación de escritorio existente (sin modificar el código) para que pueda ejecutarse en un contenedor MSIX. El marco de soporte técnico de paquetes ayuda a la aplicación a seguir los procedimientos recomendados del entorno de tiempo de ejecución moderno.

En este artículo se proporciona un vistazo detallado a cada componente del Framework de Soporte de Paquetes y una guía paso a paso para usarlo.

Comprende lo que hay dentro de un marco de soporte para paquetes.

El marco de soporte técnico de paquetes contiene un archivo ejecutable, un archivo DLL del administrador en tiempo de ejecución y un conjunto de correcciones en tiempo de ejecución.

Este es el proceso:

1. Cree un archivo de configuración que especifique las correcciones que desea aplicar a la aplicación.
2. Modifique el paquete para que apunte al archivo ejecutable del iniciador del marco de compatibilidad de paquetes (PSF).

Cuando los usuarios inician la aplicación, el iniciador del marco de compatibilidad de paquetes es el primer ejecutable que se ejecuta. Lee tu archivo de configuración e inyecta las correcciones en tiempo de ejecución y la DLL del administrador del tiempo de ejecución en el proceso de la aplicación. El administrador en tiempo de ejecución aplica la corrección cuando la aplicación la necesita para ejecutarse dentro de un contenedor MSIX.

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

En primer lugar, cree un paquete para la aplicación. A continuación, instálelo, ejecútelo y observe su comportamiento. Es posible que reciba mensajes de error que pueden ayudarle a identificar un problema de compatibilidad. También puede usar El Monitor de procesos 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 ayudarle a comprender los problemas de compatibilidad de aplicaciones. Después de abrir el Monitor de procesos, agregue un 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, puede filtrar eventos para mostrar solo los errores.

Si sospecha de un fallo en el acceso al sistema de archivos, busque eventos fallidos que se encuentren en los directorios System32/SysWOW64 o en la ruta del archivo del paquete. Los filtros también pueden ayudar aquí. Comience en la parte inferior de esta lista y desplácese hacia arriba. Los errores que aparecen en la parte inferior de esta lista se han producido más recientemente. Preste más atención a los errores que contienen cadenas como "acceso denegado" y "ruta de acceso/nombre no encontrado" y omita las cosas que no parezcan sospechosas. PSFSample tiene dos problemas. Puede 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 desde el 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 siguiente imagen.

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

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

El PSF contiene correcciones de ejecución en tiempo real que puede usar en este momento, como el ajuste de redirección de archivos.

Corrección de redirección de archivos

Puede usar File Redirection Fixup 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 su aplicación escribe en un archivo de registro que se encuentra en el mismo directorio que el ejecutable de su aplicación, puede usar la fijación de redirección de archivo para crear ese archivo de registro en otra ubicación, como el almacén de datos local de la aplicación.

Correcciones en tiempo de ejecución de la comunidad

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

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

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

• Crear una carpeta de diseño de paquete
• Obtener los archivos del Marco de Compatibilidad de Paquetes
• Agréguelos al paquete
• Modificación del manifiesto del paquete
• Creación de un archivo de configuración

Vamos a pasar por cada tarea.

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

Si ya tiene un archivo .msix (o .appx), puede desempaquetar su contenido en una carpeta de diseño que servirá como área de almacenamiento provisional para el paquete. Puede 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á la herramienta makeappx.exe en el equipo de Windows 10: x86: C:\Program Files (x86)\Windows Kits\10\bin\x86\makeappx.exe x64: C:\Program Files (x86)\Windows Kits\10\bin\x64\makeappx.exe

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

Esto le dará algo similar a lo siguiente.

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

Obtener los archivos del Marco de Compatibilidad de Paquetes

Puede 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 mediante la herramienta de línea de comandos

Instale 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, ejecute este comando:

nuget install Microsoft.PackageSupportFramework

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

Obtención del paquete mediante Visual Studio

En Visual Studio, haga clic con el botón derecho en el nodo de la solución o del proyecto y elija uno de los comandos Administrar paquetes Nuget. Busque Microsoft.PackageSupportFramework o PSF para buscar el paquete en Nuget.org. A continuación, instálelo.

Agrega los archivos de Package Support Framework a tu paquete

Agregue los archivos DLL psF y archivos ejecutables de PSF de 32 y 64 bits necesarios al directorio del paquete. Utilice la siguiente tabla a modo de guía. También deberías incluir las correcciones en tiempo de ejecución que necesites. En nuestro ejemplo, necesitamos la corrección del tiempo de ejecución de redireccionamiento 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ía tener un aspecto similar al siguiente.

Modificación del manifiesto del paquete

Abra el manifiesto de paquete en un editor de texto y, a continuación, establezca el atributo Executable del elemento Application al nombre del archivo ejecutable del iniciador de PSF. Si conoce la arquitectura de la aplicación de destino, seleccione 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

Cree un nombre config.jsonde archivo y guarde ese archivo en la carpeta raíz del paquete. Modifique el identificador de aplicación declarado del archivo config.json para que apunte al archivo ejecutable que acaba de reemplazar. Con los conocimientos adquiridos al usar el Supervisor de procesos, también puede establecer el directorio de trabajo, así como usar la corrección de redirección de archivos para redirigir las lecturas y escrituras en archivos .log en el directorio "PSFSampleApp" relativo al paquete.

{
    "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 de config.json:

Matriz	clave	Importancia
aplicaciones	identificación	Usa el valor del atributo Id del elemento Application en el manifiesto del paquete.
aplicaciones	ejecutable	Ruta de acceso relativa al paquete al ejecutable que desea iniciar. En la mayoría de los casos, puede obtener este valor del archivo de manifiesto del paquete antes de modificarlo. Es el valor del Executable atributo del Application elemento .
aplicaciones	directorio de trabajo	(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 System32 directorio como directorio de trabajo de la aplicación.
procesos	ejecutable	En la mayoría de los casos, este será el nombre del executable configurado arriba, al cual se le ha quitado la ruta de acceso y la extensión de archivo.
Reparaciones	Dll	Ruta de acceso relativa al paquete relacionado con la corrección, .msix/.appx para cargar.
Reparaciones	configuración	(Opcional) Controla cómo se comporta el archivo DLL de corrección. El formato exacto de este valor varía en función de 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 puede usar el archivo config.json para especificar más de una aplicación, un proceso y un archivo DLL de corrección.

Empaquetar y probar la aplicación

A continuación, cree un paquete.

makeappx pack /d PackageContents /p PSFSamplePackageFixup.msix

Después, firme.

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, instale el paquete.

Nota:

Recuerde desinstalar primero el paquete.

powershell Add-AppPackage .\PSFSamplePackageFixup.msix

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

Compruebe si el marco de soporte técnico de paquetes se está ejecutando

Puede comprobar si la corrección en tiempo de ejecución se está ejecutando. Una manera de hacerlo es abrir el Administrador de tareas y hacer clic en Más detalles. Busque la aplicación a la que se aplicó el marco de compatibilidad de paquetes y expanda los detalles de la aplicación para obtener más detalles. Debería poder ver que el Package Support Framework se está ejecutando.

Uso de la corrección de seguimiento

Una técnica alternativa para diagnosticar problemas de compatibilidad de aplicaciones empaquetadas es usar Trace Fixup. Este archivo DLL se incluye con 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, agregue el archivo DLL al paquete, agregue el siguiente fragmento a su config.json y, a continuación, empaquete e instale la aplicación.

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

De forma predeterminada, Trace Fixup filtra los fallos 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 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 probable que sea mejor empezar a filtrar solo por errores inesperados y, a continuación, volver 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.

Depurar, ampliar o crear una corrección en tiempo de ejecución

Puede 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á que hacer estas cosas para tener éxito.

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

Cuando haya terminado, la solución tendrá un aspecto similar al siguiente.

Echemos un vistazo a cada proyecto de este ejemplo.

Proyecto	Propósito
Paquete de aplicación de escritorio	Este proyecto se basa en el proyecto de empaquetado de aplicaciones de Windows y genera el paquete MSIX.
Corrección en tiempo de ejecución	Se trata de un proyecto de biblioteca de Dynamic-Linked 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 soporte técnico 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, consulte 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 tiene una solución para la aplicación de escritorio, cree una nueva solución en blanco en Visual Studio.

También puede agregar cualquier proyecto de aplicación que tenga.

Adición de un proyecto de empaquetado

Si aún no tiene un proyecto de empaquetado de aplicaciones de Windows, cree uno y agréguelo a la solución.

Para obtener más información sobre el proyecto empaquetado de aplicaciones de Windows, consulte Empaquetar la aplicación mediante Visual Studio.

En el Explorador de soluciones, haga clic con el botón derecho en el proyecto de empaquetado, seleccione Editar y, a continuación, agréguelo a la parte inferior 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 de un proyecto para la corrección en tiempo de ejecución

Agregue un proyecto de Dynamic-Link biblioteca (DLL) de C++ a la solución.

Haga clic con el botón derecho en el proyecto y, a continuación, elija Propiedades.

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

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

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

Busque el paquete Nuget PSF* y, a continuación, instálelo para este proyecto.

Si desea depurar o ampliar una corrección en tiempo de ejecución existente, agregue los archivos de corrección en tiempo de ejecución que obtuvo mediante las instrucciones descritas en la sección Buscar una corrección en tiempo de ejecución de esta guía.

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

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

Agregue un proyecto Empty Project de C++ a la solución.

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

Abra las páginas de propiedades del proyecto y, en la página Configuración general, establezca la propiedad PSFLauncher32 de destino en o PSFLauncher64 en función de la arquitectura de la aplicación.

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

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

Propiedad	Importancia
Copia local	Cierto
Copiar ensamblados satélite locales	Cierto
Salida de ensamblado de referencia	Cierto
Vincular dependencias de biblioteca	Falso
Vincular entradas de dependencias de biblioteca	Falso

Configuración del proyecto de empaquetado

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

Elija el proyecto del iniciador de PSF y el proyecto de aplicación de escritorio y, a continuación, elija el botón Aceptar .

Nota:

Si no tiene el código fuente de su aplicación, simplemente elija el proyecto PSF Launcher. Le mostraremos cómo hacer referencia al archivo ejecutable al crear un archivo de configuración.

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

Agregue un archivo denominado config.json al proyecto de empaquetado y, a continuación, copie y pegue el siguiente texto json en el archivo. Establezca la propiedad Acción del paquete en Contenido.

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

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

Matriz	clave	Importancia
aplicaciones	identificación	Usa el valor del atributo Id del elemento Application en el manifiesto del paquete.
aplicaciones	ejecutable	Ruta de acceso relativa al paquete al ejecutable que desea iniciar. En la mayoría de los casos, puede obtener este valor del archivo de manifiesto del paquete antes de modificarlo. Es el valor del Executable atributo del Application elemento .
aplicaciones	directorio de trabajo	(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 System32 directorio como directorio de trabajo de la aplicación.
procesos	ejecutable	En la mayoría de los casos, este será el nombre del executable configurado arriba, al cual se le ha quitado la ruta de acceso y la extensión de archivo.
Reparaciones	Dll	Ruta de acceso relativa del paquete al archivo DLL de corrección que se cargará.
Reparaciones	configuración	(Opcional) Controla cómo se comporta la DLL de ajuste. El formato exacto de este valor varía en función de la corrección, ya que cada corrección puede interpretar este "blob" como quiera.

Cuando haya terminado, el config.json archivo 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 puede usar el archivo config.json para especificar más de una aplicación, un proceso y un archivo DLL de corrección.

Depurar una corrección en tiempo de ejecución

En Visual Studio, presione F5 para iniciar el depurador. Lo primero que se inicia es la aplicación PSF Launcher, que a su vez inicia la aplicación de escritorio de destino. Para depurar la aplicación de escritorio de destino, tendrá que asociarse manualmente al proceso de aplicación de escritorio seleccionando Depurar->Asociar al proceso y, a continuación, seleccionar el proceso de aplicación. Para permitir la depuración de una aplicación .NET con una DLL de corrección nativa en tiempo de ejecución, seleccione los tipos de código administrado y nativo (depuración en modo mixto).

Una vez configurado esto, puede 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 tiene el código fuente de su aplicación, podrá establecer puntos de interrupción solamente junto a las líneas de código en su proyecto de corrección durante la ejecución.

Dado que la depuración de F5 ejecuta la aplicación mediante la implementación de archivos flexibles 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 paquetes 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, use la implementación de paquetes .msix/.appx en lugar de la implementación de archivos flexibles de F5. Para crear un archivo de paquete .msix/.appx, use la utilidad MakeAppx del SDK de Windows, como se describió anteriormente. O bien, desde Visual Studio, haga clic con el botón derecho en el nodo del proyecto de aplicación y seleccione Tienda:> 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, la cual debe ser asociada manualmente por Visual Studio una vez iniciada.

Para solucionar este problema, use un depurador que admita la asociación de procesos secundarios. Tenga en cuenta que generalmente 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 neutraliza el mecanismo de desvío utilizado por PSFLauncher.exe para inyectar FixupRuntime.dll en la aplicación objetivo. 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 iniciar y depurar una aplicación para UWP.

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

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

En el símbolo del sistema WinDbg, habilite la depuración de procesos secundarios y establezca los puntos de interrupción adecuados.

.childdbg 1
g

(se ejecuta hasta que se inicia la aplicación de destino y se interrumpe en el depurador)

sxe ld fixup.dll
g

(ejecute 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.

Apoyo

¿Tiene preguntas? Pregúntenos en el espacio de conversación del Package Support Framework en el sitio de la comunidad tecnológica de MSIX.