Manifestes d’application

Un manifeste d’application (également appelé manifeste d’application côte à côte ou manifeste fusion) est un fichier XML qui décrit et identifie les assemblys côte à côte, privés et partagés, avec lesquels une application doit établir une liaison au moment de l’exécution. Il doit s'agir des mêmes versions d'assembly qui ont été utilisées pour tester l'application. Les manifestes d’applications peuvent également décrire les métadonnées des fichiers privés pour l’application.

Pour obtenir la liste complète du schéma XML, consultez le schéma du fichier manifeste.

Les manifestes d’applications ont les éléments et attributs suivants.

Élément	Attributs	Requis
assembly		Oui
	manifestVersion	Oui
noInherit		Non
assemblyIdentity		Oui
	type	Oui
	name	Oui
	language	Non
	processorArchitecture	Non
	version	Oui
	publicKeyToken	Non
compatibilité		Non
application		Non
supportedOS		Non
	Id	Oui
maxversiontested		Non
	Id	Oui
dépendance		Non
dependentAssembly		Non
fichier		Non
	name	Oui
	hashalg	Non
	hash	Non
activatableClass		Non
	name	Oui
	threadingModel	Oui
activeCodePage		Non
autoElevate		Non
disableTheming		Non
disableWindowFiltering		Non
dpiAware		Non
dpiAwareness		Non
gdiScaling		Non
highResolutionScrollingAware		Non
longPathAware		Non
printerDriverIsolation		Non
ultraHighResolutionScrollingAware		Non
msix		Non
heapType		Non
supportedArchitectures		Non
trustInfo		Non

Emplacement du fichier

Si possible, vous devez incorporer le manifeste d’application en tant que ressource dans le fichier .exe de votre application ou .dll. Si vous ne pouvez pas le faire, vous pouvez placer le fichier manifeste de l’application dans le même répertoire que .exe ou .dll.

Pour plus d’informations, consultez Installation d’assemblys côte à côte.

Nom de fichier

Par convention, un manifeste d’application doit avoir le même nom que le fichier exécutable de votre application, avec l’extension .manifest ajoutée.

Par exemple, un manifeste d’application qui fait référence à example.exe ou example.dll doit utiliser la syntaxe de nom de fichier suivante (si l’ID de ressource est 1, vous pouvez omettre le segment <ID de ressource> de la syntaxe).

exemple.exe.<ID de ressource>.manifest

exemple.dll.<ID de ressource>.manifest

Éléments

Les noms d’éléments et d’attributs respectent la casse. Les valeurs des éléments et des attributs ne respectent pas la casse, à l’exception de la valeur de l’attribut de type.

assembly

Élément conteneur. Son premier sous-élément doit être un élément noInherit ou assemblyIdentity. Obligatoire.

L’élément assembly doit se trouver dans l’espace de noms urn:schemas-microsoft-com:asm.v1. Les éléments enfants de l’assembly doivent également se trouver dans cet espace de noms, par héritage ou par balisage.

Chaque élément assembly possède les attributs suivants.

Attribut	Description
manifestVersion	L’attribut manifestVersion doit être défini sur 1.0.

noInherit

Incluez cet élément dans un manifeste d’application pour définir les contextes d’activation générés à partir du manifeste avec l’indicateur « no inherit » (sans héritage). Lorsque cet indicateur n’est pas défini dans un contexte d’activation et que le contexte d’activation est actif, il est hérité par les nouveaux threads dans le même processus, les fenêtres, les procédures de fenêtre et les appels de procédure asynchrone. La définition de cet indicateur empêche le nouvel objet d’hériter du contexte actif.

L’élément noInherit est facultatif et généralement omis. La plupart des assemblys ne fonctionnent pas correctement à l’aide d’un contexte d’activation sans héritage, car l’assembly doit être explicitement conçu pour gérer la propagation de son propre contexte d’activation. L’utilisation de l’élément noInherit nécessite que tous les assemblys dépendants référencés par le manifeste de l’application aient un élément noInherit dans leur manifeste d’assembly.

Si noInherit est utilisé dans un manifeste, il doit s’agir du premier sous-élément de l’élément assembly. L’élément assemblyIdentity doit se trouver immédiatement après l’élément noInherit. Si noInherit n’est pas utilisé, assemblyIdentity doit être le premier sous-élément de l’élément assembly. L’élément noInherit n’a aucun élément enfant. Il n’est pas un élément valide dans les manifestes d’assembly.

assemblyIdentity

Comme premier sous-élément d’un élément assembly, assemblyIdentity décrit et identifie de manière unique l’application propriétaire de ce manifeste d’application. Comme premier sous-élément d’un élément dépendantAssembly, assemblyIdentity décrit un assembly côte à côte requis par l’application. Notez que chaque assembly référencé dans le manifeste de l’application nécessite un assemblyIdentity qui correspond exactement à l’assemblyIdentity dans le manifeste d’assembly référencé.

L’élément assemblyIdentity a les attributs suivants. Il n’a pas de sous-éléments.

Attribut	Description
type	Spécifie le type d’application ou d’assembly. La valeur doit être win32 et tout en minuscules. Obligatoire.
name	Nomme de manière unique l’application ou l’assembly. Utilisez le format suivant pour le nom : Organization.Division.Name. Par exemple, Microsoft.Windows.mysampleApp. Obligatoire.
language	Identifie la langue de l’application ou de l’assembly. Si l’application ou l’assembly est spécifique à la langue, spécifiez le code de langue DHTML. Dans l’assemblyIdentity d’une application destinée à une utilisation mondiale (neutre en langue), omettez l’attribut de langue. Dans un assemblyIdentity d’un assembly destiné à une utilisation mondiale (neutre en langue), définissez la valeur de la langue sur *. facultatif.
processorArchitecture	Spécifie le processeur. Les valeurs autorisées sont x86, amd64, arm et arm64. Vous pouvez également spécifier *, ce qui garantit que toutes les plateformes sont ciblées. facultatif.
version	Spécifie la version de l’application ou de l’assembly. Utilisez le format de version en quatre parties : mmmmm.nnnnn.ooooo.ppppp. Chacune des parties séparées par des points peut être comprise entre 0 et 65535. Pour plus d’informations, consultez Versions d’assembly. Obligatoire.
publicKeyToken	Chaîne hexadécimale de 16 caractères représentant les 8 derniers octets du hachage SHA-1 de la clé publique sous laquelle l’application ou l’assembly est signé. La clé publique utilisée pour signer le catalogue doit être de 2 048 bits ou davantage. Obligatoire pour tous les assemblys côte à côte partagés.

<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
 ...
<dependency>
   <dependentAssembly>
      <assemblyIdentity
          type="win32"
          name="Microsoft.Windows.Common-Controls"
          version="6.0.0.0"
          processorArchitecture="*"
          publicKeyToken="6595b64144ccf1df"
          language="*"
       />
   </dependentAssembly>
</dependency>
...
</assembly>

compatibilité

Contient au moins une application. Il n’a aucun attribut. facultatif. Manifestes d’application sans élément compatibility par défaut pour la compatibilité Windows Vista sur Windows 7.

L’élément compatibility doit se trouver dans l’espace de noms urn:schemas-microsoft-com:compatibility.v1. Les éléments enfants de compatibility doivent également se trouver dans cet espace de noms, par héritage ou par balisage.

d'entreprise

Contient au moins un élément supportedOS. À compter de Windows 10, version 1903, il peut également contenir un élément maxversiontested facultatif. Il n’a aucun attribut. facultatif.

supportedOS

L’élément supportedOS a l’attribut suivant. Il n’a pas de sous-éléments.

Attribut

Description

Id

Définissez l’attribut Id sur {e2011457-1546-43c5-a5fe-008deee3d3f0} pour exécuter l’application à l’aide de la fonctionnalité Vista. Cela peut permettre à une application conçue pour Windows Vista de s’exécuter sur un système d’exploitation ultérieur. Définissez l’attribut Id sur {35138b9a-5d96-4fbd-8e2d-a2440225f93a} pour exécuter l’application à l’aide de la fonctionnalité Windows 7. Les applications qui prennent en charge les fonctionnalités Windows Vista, Windows 7 et Windows 8 ne nécessitent pas de manifestes distincts. Dans ce cas, ajoutez les GUID pour tous les systèmes d’exploitation Windows. Pour plus d’informations sur le comportement de l’attribut Id dans Windows, consultez le cookbook de compatibilité Windows 8 et Windows Server 2012. Les GUID suivants correspondent aux systèmes d’exploitation indiqués : {8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a} –> Windows 10, Windows 11, Windows Server 2016, Windows Server 2019 et Windows Server 2022 {1f676c76-80e1-4239-95bb-83d0f6d0da78} –> Windows 8.1 et Windows Server 2012 R2 {4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38} –> Windows 8 et Windows Server 2012 {35138b9a-5d96-4fbd-8e2d-a2440225f93a} –> Windows 7 et Windows Server 2008 R2 {e2011457-1546-43c5-a5fe-008deee3d3f0} –> Windows Vista et Windows Server 2008 Vous pouvez le tester sur Windows 7 ou Windows 8.x en exécutant le Moniteur de ressource (resmon), en accédant à l’onglet Processeur, en cliquant avec le bouton droit sur les étiquettes de colonne, « Sélectionner une colonne... » et en cochant « Contexte du système d’exploitation ». Sur Windows 8.x, vous pouvez également trouver cette colonne disponible dans le Gestionnaire des tâches (taskmgr). Le contenu de la colonne affiche la valeur la plus élevée trouvée ou « Windows Vista » comme valeur par défaut.

maxversiontested

L’élément maxversiontested spécifie les versions de Windows testées par l’application à partir de la version minimale du système d’exploitation prise en charge par l’application jusqu’à la version maximale. L’ensemble complet de versions est disponible ici. Cela est destiné à être utilisé par les applications de bureau qui utilisent XAML Islands et qui ne sont pas déployées dans un package MSIX. Cet élément est pris en charge dans Windows 10, version 1903 et versions ultérieures.

L’élément maxversiontested a l’attribut suivant. Il n’a pas de sous-éléments.

Attribut	Description
Id	Définissez l’attribut Id sur une chaîne de version en 4 parties qui spécifie la version maximale de Windows sur laquelle l’application a été testée. Par exemple, « 10.0.18362.1 » pour Windows 10, version 1903. Obligatoire.

<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
...
    <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
        <application>
            <!-- Windows 10, version 1903 -->
            <maxversiontested Id="10.0.18362.1"/>
            <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
        </application>
    </compatibility>
...
</assembly>

dependency

Contient au moins une dependentAssembly. Il n’a aucun attribut. facultatif.

dependentAssembly

Le premier sous-élément de dependentAssembly doit être un élément assemblyIdentity qui décrit un assembly côte à côte requis par l’application. Chaque dependentAssembly doit se trouver à l’intérieur d’une seule dépendance. Il n’a aucun attribut.

fichier

Spécifie les fichiers privés pour l’application. facultatif.

L’élément file contient les attributs indiqués dans le tableau suivant.

Attribut	Description
name	Nom de fichier. Par exemple, Comctl32.dll. Obligatoire.
hashalg	Algorithme utilisé pour créer un hachage du fichier. Cette valeur doit être SHA1. facultatif.
hash	Hachage du fichier référencé par son nom. Chaîne hexadécimale de longueur en fonction de l’algorithme de hachage. facultatif.

activatableClass

Permet aux applications de bureau non empaquetées d’utiliser des composants Windows Runtime (WinRT) définis par l’utilisateur. Cet élément est pris en charge dans Windows 10, version 1903 et versions ultérieures. Pour plus d’informations, consultez cet article.

L’élément activatableClass doit se trouver dans l’espace de noms urn:schemas-microsoft-com:winrt.v1.

L’élément activatableClass a les attributs suivants.

Attribut	Description
name	Spécifie l’identificateur de classe pour la classe activatable. Obligatoire.
threadingModel	Représente le modèle de thread cloisonné à utiliser pour activer un serveur in-process. Les valeurs valides sont both, STA et MTA. Pour plus d’informations, consultez cet article. Obligatoire.

<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
...
<file name="WinRTComponent.dll">
    <activatableClass
        name="WinRTComponent.MessageHolder"
        threadingModel="both"
        xmlns="urn:schemas-microsoft-com:winrt.v1"
     />
</file>
...
</assembly>

activeCodePage

Sur Windows 10, cet élément force un processus à utiliser UTF-8 comme page de codes de processus. Pour plus d’informations, consultez Utiliser la page de codes UTF-8. Sur Windows 10, la seule valeur valide pour activeCodePage est UTF-8.

À compter de Windows 11, cet élément permet également la sélection de la page de codes non UTF-8 héritée ou des pages de codes pour des paramètres régionaux spécifiques pour la compatibilité des applications héritées. Les applications modernes sont fortement encouragées à utiliser Unicode. Sur Windows 11, activeCodePage peut également être défini sur la valeur Legacy ou un nom de paramètres régionaux tel qu’en-US ou ja-JP.

• Sur les ordinateurs configurés sur une page de codes active système UTF-8, Legacy rétablit le processus dans les pages de codes des paramètres régionaux système. Si les paramètres régionaux système n’ont pas défini de pages de codes, Windows-1252/437 est utilisé. Le paramètre de page de codes Legacy n’est pris en charge que dans les manifestes Fusion et seulement à compter de Windows 11.
• Lorsqu’un nom de paramètres régionaux tel qu’en-US est fourni, la page de codes de processus est définie de manière appropriée pour cette page de codes de paramètres régionaux. Par exemple, Windows-1252 et 437 pour en-US, ou 932 pour ja-JP.

Cet élément a été ajouté pour la première fois dans Windows 10 version 1903 (mise à jour de mai 2019). Vous pouvez déclarer cette propriété et cibler/exécuter sur des builds Windows antérieures, mais vous devez gérer la détection et la conversion des pages de codes héritées comme d’habitude. Cet élément n’a pas d’attributs.

L’exemple suivant montre comment utiliser cet élément pour forcer le processus actuel à utiliser UTF-8 comme page de codes de processus.

<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
 ...
  <asmv3:application>
    <asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2019/WindowsSettings"> 
      <activeCodePage>UTF-8</activeCodePage> 
    </asmv3:windowsSettings>
  </asmv3:application>
 ...
</assembly>

autoElevate

Spécifie si l’élévation automatique est activée. TRUE indique qu’elle est activée. Il n’a aucun attribut. Le fichier exécutable doit être signé numériquement par Windows Publisher. À usage interne uniquement.

disableTheming

Spécifie si l’attribution d’un thème aux éléments d’interface utilisateur est désactivée. TRUE indique qu’elle est désactivée. Il n’a aucun attribut.

disableWindowFiltering

Spécifie s’il faut désactiver le filtrage de fenêtres. TRUE désactive le filtrage des fenêtres afin de pouvoir énumérer les fenêtres immersives à partir du bureau. disableWindowFiltering a été ajouté dans Windows 8 et n’a aucun attribut.

<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
 ...
  <asmv3:application>
    <asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2011/WindowsSettings">
      <disableWindowFiltering>true</disableWindowFiltering>
    </asmv3:windowsSettings>
  </asmv3:application>
 ...
</assembly>

dpiAware

Spécifie si le processus actuel est conscient des points par pouce (ppp).

Windows 10, version 1607 : l’élément dpiAware est ignoré si l’élément dpiAwareness est présent. Vous pouvez inclure les deux éléments dans un manifeste si vous souhaitez spécifier un comportement différent pour Windows 10, version 1607 que pour une version antérieure du système d’exploitation.

Le tableau suivant décrit le comportement qui résulte en fonction de la présence de l’élément dpiAware et du texte qu’il contient. Le texte dans l’élément n’est pas sensible à la casse.

État de l’élément dpiAware	Description
Absent	Par défaut, le processus actuel n’est pas conscient des points par pouce. Vous pouvez modifier ce paramètre par programmation en appelant la fonction SetProcessDpiAwareness ou SetProcessDPIAware.
Contient « true »	Le processus actuel est conscient des points par pouce du système.
Contient « false »	Windows Vista, Windows 7 et Windows 8 : le comportement est le même que lorsque dpiAware est absent. Windows 8.1 et Windows 10 : le processus actuel n’est pas conscient des points par pouce et vous ne pouvez pas modifier ce paramètre par programme en appelant la fonction SetProcessDpiAwareness ni SetProcessDPIAware.
Contient « true/pm »	Windows Vista, Windows 7 et Windows 8 : le processus actuel est conscient des points par pouce. Windows 8.1 et Windows 10 : le processus actuel est conscient des points par pouce par moniteur.
Contient « per monitor »	Windows Vista, Windows 7 et Windows 8 : le comportement est le même que lorsque dpiAware est absent. Windows 8.1 et Windows 10 : le processus actuel est conscient des points par pouce par moniteur.
Contient toute autre chaîne	Windows Vista, Windows 7 et Windows 8 : le comportement est le même que lorsque dpiAware est absent. Windows 8.1 et Windows 10 : le processus actuel n’est pas conscient des points par pouce et vous ne pouvez pas modifier ce paramètre par programme en appelant la fonction SetProcessDpiAwareness ni SetProcessDPIAware.

Pour plus d’informations sur les paramètres de sensibilisation aux points par pouce, consultez Développement d’applications de bureau haute résolution sur Windows.

dpiAware n’a aucun attribut.

<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
 ...
  <asmv3:application>
    <asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">
      <dpiAware>true</dpiAware>
    </asmv3:windowsSettings>
  </asmv3:application>
 ...
</assembly>

dpiAwareness

Spécifie si le processus actuel est conscient des points par pouce (ppp).

La version minimale du système d’exploitation qui prend en charge l’élément dpiAwareness est Windows 10, version 1607. Pour les versions qui prennent en charge l’élément dpiAwareness, dpiAwareness remplace l’élément dpiAware. Vous pouvez inclure les deux éléments dans un manifeste si vous souhaitez spécifier un comportement différent pour Windows 10, version 1607 que pour une version antérieure du système d’exploitation.

L’élément dpiAwareness peut contenir un seul élément ou une liste d’éléments séparés par des virgules. Dans ce dernier cas, le premier (le plus à gauche) de la liste reconnue par le système d’exploitation est utilisé. De cette façon, vous pouvez spécifier différents comportements pris en charge dans les futures versions du système d’exploitation Windows.

Le tableau suivant décrit le comportement qui résulte en fonction de la présence de l’élément dpiAwareness et du texte qu’il contient dans son élément reconnu le plus à gauche. Le texte dans l’élément n’est pas sensible à la casse.

État de l’élément dpiAwareness :	Description
L’élément est absent	L’élément dpiAware spécifie si le processus est conscient des points par pouce.
Ne contient aucun élément reconnu	Par défaut, le processus actuel n’est pas conscient des points par pouce. Vous pouvez modifier ce paramètre par programmation en appelant la fonction SetProcessDpiAwareness ou SetProcessDPIAware.
Le premier élément reconnu est « system »	Le processus actuel est conscient des points par pouce du système.
Le premier élément reconnu est « permonitor »	Le processus actuel est conscient des points par pouce par moniteur.
Le premier élément reconnu est « permonitorv2 »	Le processus actuel utilise le contexte de sensibilisation des points par pouce par moniteur v2. Cet élément est reconnu uniquement sur Windows 10 version 1703 ou ultérieure.
Le premier élément reconnu est « unaware »	Le processus actuel n’est pas conscient des points par pouce. Vous ne pouvez pas modifier ce paramètre par programmation en appelant la fonction SetProcessDpiAwareness ni SetProcessDPIAware.

Pour plus d’informations sur les paramètres de sensibilisation aux points par pouce pris en charge par cet élément, consultez DPI_AWARENESS et DPI_AWARENESS_CONTEXT.

dpiAwareness n’a aucun attribut.

<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
 ...
  <asmv3:application>
    <asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">
      <dpiAwareness>PerMonitorV2, unaware</dpiAwareness>
    </asmv3:windowsSettings>
  </asmv3:application>
 ...
</assembly>

gdiScaling

Spécifie si la mise à l’échelle GDI est activée. La version minimale du système d’exploitation qui prend en charge l’élément gdiScaling est Windows 10 version 1703.

L’infrastructure GDI (Graphics Device Interface) peut appliquer la mise à l’échelle PPP aux primitives et au texte par moniteur sans mettre à jour l’application elle-même. Cela peut être utile pour les applications GDI qui ne sont plus mises à jour activement.

Les graphismes non vectoriels (tels que les bitmaps, les icônes ou les barres d’outils) ne peuvent pas être mis à l’échelle par cet élément. En outre, les graphismes et le texte apparaissant dans les bitmaps construits dynamiquement par les applications ne peuvent pas non plus être mis à l’échelle par cet élément. Pour plus d’informations, consultez Amélioration de l’expérience en haute résolution dans les applications bureautiques basées sur GDI.

Vous pouvez modifier ce paramètre par programmation en appelant la fonction SetThreadDpiAwarenessContext ou SetProcessDpiAwarenessContext avec la valeur DPI_AWARENESS_CONTEXT_UNAWARE_GDISCALED.

TRUE indique que cet élément est activé. Il n’a aucun attribut.

<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
 ...
  <asmv3:application>
    <asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2017/WindowsSettings">
      <gdiScaling>true</gdiScaling>
    </asmv3:windowsSettings>
  </asmv3:application>
 ...
</assembly>

highResolutionScrollingAware

Spécifie si la prise en charge du défilement haute résolution est activée. TRUE indique qu’elle est activée. Il n’a aucun attribut.

longPathAware

Autorise les chemins dont la longueur dépasse MAX_PATH. Cet élément est pris en charge dans Windows 10, version 1607 et ultérieure. Pour plus d’informations, consultez cet article.

<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
 ...
  <asmv3:application>
    <asmv3:windowsSettings xmlns:ws2="http://schemas.microsoft.com/SMI/2016/WindowsSettings">
      <ws2:longPathAware>true</ws2:longPathAware>
    </asmv3:windowsSettings>
  </asmv3:application>
 ...
</assembly>

printerDriverIsolation

Spécifie si l’isolation du pilote d’imprimante est activée. TRUE indique qu’elle est activée. Il n’a aucun attribut. L’isolation des pilotes d’imprimante améliore la fiabilité du service d’impression Windows en permettant aux pilotes d’imprimante de s’exécuter dans des processus distincts du processus dans lequel le spouleur d’impression s’exécute. Prise en charge de l’isolation des pilotes d’imprimante démarrée dans Windows 7 et Windows Server 2008 R2. Une application peut déclarer l’isolation du pilote d’imprimante dans son manifeste d’application pour s’isoler du pilote d’imprimante et améliorer sa fiabilité. Autrement dit, l’application ne se bloque pas en cas d’erreur du pilote d’imprimante.

<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
 ...
  <asmv3:application>
    <asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2011/WindowsSettings">
      <printerDriverIsolation>true</printerDriverIsolation>
    </asmv3:windowsSettings>
  </asmv3:application>
 ...
</assembly>

ultraHighResolutionScrollingAware

Spécifie si la prise en charge du défilement ultra-haute résolution est activée. TRUE indique qu’elle est activée. Il n’a aucun attribut.

msix

Spécifie les informations d’identité d’un package avec un emplacement externe pour l’application actuelle (voir Accorder une identité de package en empaquetant avec un emplacement externe). Cet élément est pris en charge dans Windows 10, version 2004 et versions ultérieures.

L’élément msix doit se trouver dans l’espace de noms urn:schemas-microsoft-com:msix.v1. Il contient les attributs indiqués dans le tableau suivant.

Attribut	Description
publisher	Décrit les informations sur l’éditeur. Cette valeur doit correspondre à l’attribut Publisher dans l’élément Identity dans le manifeste du package de votre application empaquetée avec un emplacement externe.
nom_package	Cette rubrique décrit le contenu du package. Cette valeur doit correspondre à l’attribut Name dans l’élément Identity dans le manifeste du package de votre application empaquetée avec un emplacement externe.
applicationId	Identificateur unique de l’application. Cette valeur doit correspondre à l’attribut Id dans l’élément Application dans le manifeste du package de votre application empaquetée avec un emplacement externe.

<?xml version="1.0" encoding="utf-8"?>
<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
  <assemblyIdentity version="1.0.0.0" name="Contoso.PhotoStoreApp"/>
  <msix xmlns="urn:schemas-microsoft-com:msix.v1"
          publisher="CN=Contoso"
          packageName="ContosoPhotoStore"
          applicationId="ContosoPhotoStore"
        />
</assembly>

heapType

Remplace l’implémentation par défaut du tas pour les API de tas Win32 à utiliser.

• La valeur SegmentHeap indique que le tas de segment sera utilisé. Le tas de segment est une implémentation de tas moderne qui réduit généralement votre utilisation globale de la mémoire. Cet élément est pris en charge dans Windows 10, version 2004 (build 19041) et versions ultérieures.
• Toutes les autres valeurs sont ignorées.

Cet élément n’a pas d’attributs.

<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
 ...
  <asmv3:application>
    <asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2020/WindowsSettings">
      <heapType>SegmentHeap</heapType>
    </asmv3:windowsSettings>
  </asmv3:application>
 ...
</assembly>

supportedArchitectures

Pour les exécutables .NET Framework en IL uniquement, précise une liste d’architectures de processeurs natifs avec lesquelles l’application est compatible. Peut contenir une ou plusieurs des valeurs suivantes, séparées par des espaces :

• amd64
• arm64

Cet élément n’a pas d’attributs.

Cet élément est supporté dans Windows 11, version 24H2 et ultérieures.

<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
 ...
  <asmv3:application>
    <asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2024/WindowsSettings">
      <supportedArchitectures>amd64 arm64</supportedArchitectures>
    </asmv3:windowsSettings>
  </asmv3:application>
 ...
</assembly>

trustInfo

Toutes les applications compatibles UAC doivent avoir un niveau d’exécution demandé ajouté au manifeste de l’application. Les niveaux d’exécution demandés indiquent les privilèges requis pour une application. Pour plus d’informations, consultez Comment le contrôle de compte d’utilisateur (UAC) affecte votre application.

Le niveau d’exécution demandé est spécifié avec l’attribut level du descendant requestedExecutionLevel de l’élément trustInfo. Les valeurs autorisées pour level sont les suivantes :

Valeur	Description
asInvoker	L’application s’exécute au même niveau d’autorisation que le processus qui l’a démarré. Vous pouvez élever l’application à un niveau d’autorisation supérieur en sélectionnant Exécuter en tant qu’administrateur.
requireAdministrator	L’application s’exécute à l’aide des autorisations d’administrateur. L’utilisateur qui démarre l’application doit être membre du groupe Administrateurs. Si le processus d’ouverture n’est pas en cours d’exécution avec des autorisations d’administration, le système demande des informations d’identification.
highestAvailable	L’application s’exécute au niveau d’autorisation le plus élevé qui lui est possible. Si l’utilisateur qui démarre l’application est membre du groupe Administrateurs, cette option est la même que level="requireAdministrator". Si le niveau d’autorisation disponible le plus élevé est supérieur au niveau du processus d’ouverture, le système demande des informations d’identification.

La définition de level sur highestAvailable garantit que l’application s’exécutera correctement avec les utilisateurs membres du groupe Administrateurs et ceux qui ne le sont pas. Si l’application ne peut fonctionner qu’avec un accès administratif au système, le marquage de l’application avec un niveau d’exécution demandé de requireAdministrator garantit que le système identifie ce programme en tant qu’application administrative et effectue les étapes d’élévation nécessaires.

Par défaut, l'éditeur de liens Visual C++ incorpore un fragment du contrôle de compte d'utilisateur dans le manifeste d'une application avec un niveau d'exécution asInvoker.

L’élément requestedExecutionLevel a également un attribut facultatif uiAccess. Définissez cette valeur sur true si vous souhaitez que l’application contourne les niveaux de protection de l’interface utilisateur et dirige l’entrée vers des fenêtres d’autorisation supérieure sur le bureau. Définissez cet attribut sur true uniquement pour les applications d’accessibilité de l’interface utilisateur. La valeur par défaut est false. Des restrictions supplémentaires des paramètres de stratégie de sécurité peuvent être appliquées, consultez Contrôle de compte d’utilisateur : élever uniquement les applications UIAccess installées à des emplacements sécurisés. Pour plus d’informations, consultez Considérations relatives à la sécurité pour les technologies d’assistance.

La spécification du nœud RequestedExecutionLevel désactive la virtualisation des fichiers et du Registre. Si vous souhaitez utiliser la virtualisation de fichiers système et du Registre pour la compatibilité descendante, omettez le nœud RequestedExecutionLevel.

<trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
  <security>
    <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
      <requestedExecutionLevel level="asInvoker" uiAccess="false" />
    </requestedPrivileges>
  </security>
</trustInfo>

Exemple

Voici un exemple de manifeste d’application pour une application nommée MySampleApp.exe. L’application utilise l’assembly côte à côte SampleAssembly.

<?xml version="1.0" encoding="UTF-8"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
   <assemblyIdentity type="win32" name="MyOrganization.MyDivision.MySampleApp" version="6.0.0.0" processorArchitecture="*" />
   <dependency>
      <dependentAssembly>
         <assemblyIdentity type="win32" name="Proseware.Research.SampleAssembly" version="6.0.0.0" processorArchitecture="*" publicKeyToken="0000000000000000" />
      </dependentAssembly>
   </dependency>
   <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
      <application>
         <!-- Windows 10 and Windows 11 -->
         <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
         <!-- Windows 8.1 -->
         <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}" />
         <!-- Windows 8 -->
         <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}" />
         <!-- Windows 7 -->
         <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}" />
         <!-- Windows Vista -->
         <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}" />
      </application>
   </compatibility>
</assembly>