Remarque
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Un manifeste est un document XML qui identifie de façon unique un assembly. Il contient des informations utilisées pour la liaison et l’activation, telles que les classes COM, les interfaces et les bibliothèques de types. Un manifeste peut être un fichier XML externe ou une ressource intégrée dans une application ou un assembly. Le manifeste d’une application isolée sert à gérer les noms et les versions des assemblys partagés côte à côte auxquels l’application doit se lier au moment de l’exécution. Le manifeste d’un assembly côte à côte spécifie ses dépendances en termes de noms, de versions, de ressources et d’autres assemblys.
Il existe deux façons de créer un manifeste pour une application isolée ou un assembly côte à côte. Tout d’abord, l’auteur de l’assembly peut créer manuellement un fichier manifeste en suivant les règles et les exigences en matière d’attribution de noms. Pour plus d’informations, consultez Informations de référence sur les fichiers manifeste. Sinon, si un programme dépend uniquement des assemblys Microsoft C++ (MSVC), tels que CRT, MFC, ATL ou d’autres, l’éditeur de liens peut générer automatiquement un manifeste.
Les en-têtes des bibliothèques MSVC contiennent des informations d’assembly et lorsque ces bibliothèques sont incluses dans le code de l’application, ces informations d’assembly sont utilisées par l’éditeur de liens pour créer un manifeste pour le fichier binaire final. Par défaut, l’éditeur de liens n’intègre pas le fichier manifeste dans le fichier binaire. L’utilisation d’un manifeste en tant que fichier externe peut ne pas convenir à tous les scénarios. Par exemple, il est recommandé que les assemblys privés aient des manifestes intégrés. Dans les générations en ligne de commande, telles que celles qui utilisent NMAKE pour générer du code, vous pouvez utiliser l’option /MANIFEST:EMBED de l’éditeur de liens pour intégrer le manifeste. Vous pouvez également intégrer un manifeste à l’aide de l’outil Manifeste. Pour plus d’informations, consultez Génération de manifeste au niveau de la ligne de commande. Lorsque vous générez des projets dans Visual Studio, un manifeste peut être intégré en définissant une propriété pour l’outil Manifeste dans la boîte de dialogue Propriétés du projet, comme décrit dans la section suivante.
Génération de manifeste dans Visual Studio
Vous pouvez demander à Visual Studio de générer un fichier manifeste pour un projet particulier dans la boîte de dialogue Pages de propriétés du projet. Sous Propriétés de configuration, sélectionnez Éditeur de liens>Fichier manifeste>Générer le manifeste. Par défaut, les propriétés des nouveaux projets sont définies pour générer un fichier manifeste. Toutefois, il est possible de désactiver la génération du manifeste en modifiant la propriété Générer le manifeste du projet. Lorsque cette propriété est définie sur Oui, un manifeste est généré pour le projet. Sinon, l’éditeur de liens ignore les informations d’assembly lors de la résolution des dépendances du code de l’application et ne génère pas de manifeste.
Le système de génération dans Visual Studio permet soit d’intégrer le manifeste dans le fichier d’application binaire final, soit de le générer en tant que fichier externe. Ce comportement est contrôlé par l’option Intégrer le manifeste dans la boîte de dialogue Propriétés du projet. Pour définir cette propriété, ouvrez le nœud Outil Manifeste, puis sélectionnez Entrée et Sortie. Si le manifeste n’est pas intégré, il est généré en tant que fichier externe et enregistré dans le même répertoire que le fichier binaire final. Si le manifeste est intégré, Visual Studio procède à son intégration finale à l’aide du processus suivant :
Après compilation du code source en fichiers objets, l’éditeur de liens collecte les informations d’assemblys dépendants. Lors de la création du fichier binaire final, l’éditeur de liens génère un manifeste intermédiaire utilisé ultérieurement pour générer le manifeste final.
Une fois le manifeste intermédiaire et la liaison terminés, l’outil Manifeste fusionne les informations pour créer le manifeste final et l’enregistre en tant que fichier externe.
Le système de génération de projet détecte ensuite si le manifeste généré par l’outil Manifeste contient des informations différentes de celles déjà intégrées dans le fichier binaire.
Si le manifeste intégré dans le fichier binaire est différent du manifeste généré par l’outil Manifeste, ou si aucun manifeste n’est intégré dans le fichier binaire, Visual Studio relance l’éditeur de liens une seconde fois pour intégrer le fichier manifeste externe dans le fichier binaire en tant que ressource.
Si le manifeste intégré dans le fichier binaire est identique au manifeste généré par l’outil Manifeste, le processus de génération se poursuit normalement.
Le manifeste est intégré dans le fichier binaire final en tant que ressource de texte. Vous pouvez l’afficher en ouvrant le fichier binaire final dans Visual Studio. Pour vous assurer que le manifeste pointe vers les bibliothèques correctes, suivez les étapes décrites dans Présentation des dépendances d’une application Microsoft C++. Vous pouvez également consulter les recommandations décrites dans l’article Résolution des problèmes.
Génération de manifeste au niveau de la ligne de commande
Lorsque vous générez des applications C/C++ depuis la ligne de commande à l’aide de NMAKE ou d’outils similaires, le manifeste est généré une fois que l’éditeur de liens a traité tous les fichiers objets et généré le fichier binaire final. L’éditeur de liens collecte les informations d’assembly stockées dans les fichiers objets et combine ces informations dans un fichier manifeste final. Par défaut, l’éditeur de liens génère un fichier nommé <binary_name>.<extension>.manifest pour décrire le fichier binaire final. L’éditeur de liens peut également intégrer un fichier manifeste directement dans le fichier binaire en utilisant l’option /MANIFEST:EMBED de l’éditeur de liens.
Il existe plusieurs autres façons d’intégrer un manifeste dans le fichier binaire final, comme en utilisant l’outil Manifeste (mt.exe) ou en compilant le manifeste dans un fichier de ressources. Vous devez suivre des règles spécifiques lorsque vous intégrez un manifeste afin d’activer certaines fonctionnalités telles que la liaison incrémentielle, la signature ou la fonction Modifier & Continuer. Ces règles ainsi que d’autres options sont abordées dans la section suivante.
Comment intégrer un manifeste dans une application C/C++
Nous vous recommandons d’intégrer le manifeste de votre application ou bibliothèque dans le fichier binaire final. Cette approche garantit un comportement d’exécution correct dans la plupart des scénarios. Par défaut, Visual Studio tente d’intégrer le manifeste lorsqu’il génère un projet. Toutefois, si vous générez votre application à l’aide de NMAKE, vous devez apporter quelques modifications au makefile. Cette section montre comment modifier les makefiles pour intégrer automatiquement le manifeste dans le fichier binaire final.
Deux approches
Il existe deux façons d’intégrer le manifeste dans une application ou une bibliothèque.
Si vous n’effectuez pas de génération incrémentielle, vous pouvez directement intégrer le manifeste à l’aide d’une ligne de commande comme celle-ci, à exécuter après la génération :
mt.exe -manifest MyApp.exe.manifest -outputresource:MyApp.exe;1ou
mt.exe -manifest MyLibrary.dll.manifest -outputresource:MyLibrary.dll;2Utilisez 1 pour un EXE et 2 pour une DLL.
Si vous effectuez une génération incrémentielle, procédez comme suit :
Liez le fichier binaire pour générer le fichier
MyApp.exe.manifest.Convertissez le manifeste en fichier de ressources.
Relancez la liaison (de façon incrémentielle) pour intégrer la ressource de manifeste dans le fichier binaire.
Les exemples suivants montrent comment modifier les makefiles pour intégrer ces deux techniques.
Makefiles (avant modification)
Voici un script NMAKE pour MyApp.exe, une application simple créée à partir d’un seul fichier :
# build MyApp.exe
!if "$(DEBUG)" == "1"
CPPFLAGS=$(CPPFLAGS) /MDd
LFLAGS=$(LFLAGS) /INCREMENTAL
!else
CPPFLAGS=$(CPPFLAGS) /MD
!endif
MyApp.exe : MyApp.obj
link $** /out:$@ $(LFLAGS)
MyApp.obj : MyApp.cpp
clean :
del MyApp.obj MyApp.exe
Si ce script est exécuté tel quel avec Visual Studio, il crée MyApp.exe correctement. Il crée également le fichier manifeste externe MyApp.exe.manifest, utilisé par le système d’exploitation pour charger des assemblys dépendants au moment de l’exécution.
Le script NMAKE pour MyLibrary.dll est similaire :
# build MyLibrary.dll
!if "$(DEBUG)" == "1"
CPPFLAGS=$(CPPFLAGS) /MDd
LFLAGS=$(LFLAGS) /DLL /INCREMENTAL
!else
CPPFLAGS=$(CPPFLAGS) /MD
LFLAGS=$(LFLAGS) /DLL
!endif
MyLibrary.dll : MyLibrary.obj
link $** /out:$@ $(LFLAGS)
MyLibrary.obj : MyLibrary.cpp
clean :
del MyLibrary.obj MyLibrary.dll
Makefiles (après modification)
Pour la génération avec des manifestes intégrés, vous devez apporter quatre petites modifications aux makefiles d’origine. Pour le makefile MyApp.exe :
# build MyApp.exe
!include makefile.inc
#^^^^^^^^^^^^^^^^^^^^ Change #1. (Add full path if necessary.)
!if "$(DEBUG)" == "1"
CPPFLAGS=$(CPPFLAGS) /MDd
LFLAGS=$(LFLAGS) /INCREMENTAL
!else
CPPFLAGS=$(CPPFLAGS) /MD
!endif
MyApp.exe : MyApp.obj
link $** /out:$@ $(LFLAGS)
$(_VC_MANIFEST_EMBED_EXE)
#^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Change #2
MyApp.obj : MyApp.cpp
clean :
del MyApp.obj MyApp.exe
$(_VC_MANIFEST_CLEAN)
#^^^^^^^^^^^^^^^^^^^^^^^^ Change #3
!include makefile.target.inc
#^^^^^^^^^^^^^^^^^^^^^^^^^ Change #4. (Add full path if necessary.)
Pour le makefile MyLibrary.dll :
# build MyLibrary.dll
!include makefile.inc
#^^^^^^^^^^^^^^^^^^^^ Change #1. (Add full path if necessary.)
!if "$(DEBUG)" == "1"
CPPFLAGS=$(CPPFLAGS) /MDd
LFLAGS=$(LFLAGS) /DLL /INCREMENTAL
!else
CPPFLAGS=$(CPPFLAGS) /MD
LFLAGS=$(LFLAGS) /DLL
!endif
MyLibrary.dll : MyLibrary.obj
link $** /out:$@ $(LFLAGS)
$(_VC_MANIFEST_EMBED_DLL)
#^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Change #2.
MyLibrary.obj : MyLibrary.cpp
clean :
del MyLibrary.obj MyLibrary.dll
$(_VC_MANIFEST_CLEAN)
#^^^^^^^^^^^^^^^^^^^^^^^^ Change #3.
!include makefile.target.inc
#^^^^^^^^^^^^^^^^^^^^^^^^^ Change #4. (Add full path if necessary.)
Les makefiles incluent désormais deux fichiers qui effectuent le travail réel, makefile.inc et makefile.target.inc.
Créez makefile.inc et copiez-y le contenu suivant :
# makefile.inc -- Include this file into existing makefile at the very top.
# _VC_MANIFEST_INC specifies whether build is incremental (1 - incremental).
# _VC_MANIFEST_BASENAME specifies name of a temporary resource file.
!if "$(DEBUG)" == "1"
CPPFLAGS=$(CPPFLAGS) /MDd
LFLAGS=$(LFLAGS) /INCREMENTAL
_VC_MANIFEST_INC=1
_VC_MANIFEST_BASENAME=__VC90.Debug
!else
CPPFLAGS=$(CPPFLAGS) /MD
_VC_MANIFEST_INC=0
_VC_MANIFEST_BASENAME=__VC90
!endif
####################################################
# Specifying name of temporary resource file used only in incremental builds:
!if "$(_VC_MANIFEST_INC)" == "1"
_VC_MANIFEST_AUTO_RES=$(_VC_MANIFEST_BASENAME).auto.res
!else
_VC_MANIFEST_AUTO_RES=
!endif
####################################################
# _VC_MANIFEST_EMBED_EXE - command to embed manifest in EXE:
!if "$(_VC_MANIFEST_INC)" == "1"
#MT_SPECIAL_RETURN=1090650113
#MT_SPECIAL_SWITCH=-notify_resource_update
MT_SPECIAL_RETURN=0
MT_SPECIAL_SWITCH=
_VC_MANIFEST_EMBED_EXE= \
if exist $@.manifest mt.exe -manifest $@.manifest -out:$(_VC_MANIFEST_BASENAME).auto.manifest $(MT_SPECIAL_SWITCH) & \
if "%ERRORLEVEL%" == "$(MT_SPECIAL_RETURN)" \
rc /r $(_VC_MANIFEST_BASENAME).auto.rc & \
link $** /out:$@ $(LFLAGS)
!else
_VC_MANIFEST_EMBED_EXE= \
if exist $@.manifest mt.exe -manifest $@.manifest -outputresource:$@;1
!endif
####################################################
# _VC_MANIFEST_CLEAN - command to clean resources files generated temporarily:
!if "$(_VC_MANIFEST_INC)" == "1"
_VC_MANIFEST_CLEAN=-del $(_VC_MANIFEST_BASENAME).auto.res \
$(_VC_MANIFEST_BASENAME).auto.rc \
$(_VC_MANIFEST_BASENAME).auto.manifest
!else
_VC_MANIFEST_CLEAN=
!endif
# End of makefile.inc
####################################################
Créez désormais makefile.target.inc et copiez-y le contenu suivant :
# makefile.target.inc - include this at the very bottom of the existing makefile
####################################################
# Commands to generate initial empty manifest file and the RC file
# that references it, and for generating the .res file:
$(_VC_MANIFEST_BASENAME).auto.res : $(_VC_MANIFEST_BASENAME).auto.rc
$(_VC_MANIFEST_BASENAME).auto.rc : $(_VC_MANIFEST_BASENAME).auto.manifest
type <<$@
#include <winuser.h>
1RT_MANIFEST"$(_VC_MANIFEST_BASENAME).auto.manifest"
<< KEEP
$(_VC_MANIFEST_BASENAME).auto.manifest :
type <<$@
<?xml version='1.0' encoding='UTF-8' standalone='yes'?>
<assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'>
</assembly>
<< KEEP
# end of makefile.target.inc
Voir aussi
Génération d’applications isolées et d’assemblys côte à côte C/C++
Concepts d’applications isolées et d’assemblys côte à côte
Dépannage d’applications isolées et d’assemblys côte à côte C/C++
/INCREMENTAL (Lier par incrément)
/MANIFEST (Créer un manifeste d’assembly côte à côte)
Assemblys de nom fort (signature d’assembly) (C++/CLI)
Modifier & Continuer