Dela via

Förstå manifestgenerering för C/C++-program

Ett manifest är ett XML-dokument som unikt identifierar en sammansättning. Den innehåller information som används för bindning och aktivering, till exempel COM-klasser, gränssnitt och typbibliotek. Ett manifest kan vara en extern XML-fil eller en resurs som är inbäddad i ett program eller en sammansättning. Manifestet för en isolerad applikation används för att hantera namn och versioner av flera samtidigt existerande delade sammansättningar som applikationen ska binda till vid körningstid. Manifestet för en sida-vid-sida-sammansättning anger dess beroenden för namn, versioner, resurser och andra sammansättningar.

Det finns två sätt att skapa ett manifest för ett isolerat program eller en sida vid sida-sammansättning. Först kan författaren till sammansättningen manuellt skapa en manifestfil genom att följa reglerna och namngivningskraven. Mer information finns i Referens för manifestfiler. Alternativt, om ett program bara är beroende av MSVC-komponenter som CRT, MFC, ATL eller andra, kan länkaren generera ett manifest automatiskt.

Sidhuvudena för MSVC-bibliotek innehåller sammansättningsinformation, och när biblioteken ingår i programkoden används den här sammansättningsinformationen av länkaren för att skapa ett manifest för den slutliga binära filen. Som standard bäddar inte länkaren in manifestfilen i binärfilen. Att ha ett manifest som en extern fil kanske inte fungerar för alla scenarier. Vi rekommenderar till exempel att för privata sammanställningar ha inbäddade manifest. I kommandoradsversioner, till exempel sådana som använder NMAKE för att skapa kod, kan du använda länkalternativet /MANIFEST:EMBED för att bädda in manifestet. Alternativt kan ett manifest bäddas in med hjälp av manifestverktyget. Mer information finns i Manifestgenerering på kommandoraden. När du skapar i Visual Studio kan ett manifest bäddas in genom att ange en egenskap för manifestverktyget i dialogrutan Projektegenskaper enligt beskrivningen i nästa avsnitt.

Manifestgenerering i Visual Studio

Du kan be Visual Studio att generera en manifestfil för ett visst projekt i projektets dialogruta Egenskapssidor . Under Konfigurationsegenskaper väljer du Linker>Manifestfil>Generera manifest. Som standard är projektegenskaperna för nya projekt inställda på att generera en manifestfil. Det går dock att inaktivera genereringen av manifestet för ett projekt med hjälp av egenskapen Generera manifest för projektet. När den här egenskapen är inställd på Ja genereras manifestet för projektet. Annars ignorerar länkaren sammansättningsinformation vid lösning av beroenden för applikationskoden och genererar inte manifest.

Byggsystemet i Visual Studio gör att manifestet kan bäddas in i den slutliga binära programfilen eller genereras som en extern fil. Det här beteendet styrs av alternativet Bädda in manifest i dialogrutan Projektegenskaper . Om du vill ange den här egenskapen öppnar du noden Manifestverktyg och väljer sedan Indata och Utdata. Om manifestet inte är inbäddat genereras det som en extern fil och sparas i samma katalog som den slutliga binära filen. Om manifestet är inbäddat bäddar Visual Studio in de sista manifesten med hjälp av följande process:

  1. När källkoden har kompilerats till objektfiler samlar länkaren in beroende sammansättningsinformation. Även om den länkar den slutliga binärfilen genererar länkaren ett mellanliggande manifest som används senare för att generera det slutliga manifestet.

  2. När mellanliggande manifest och länkning har slutförts sammanfogar manifestverktyget ett slutligt manifest och sparar det som en extern fil.

  3. Projektets byggsystem identifierar sedan om manifestet som genereras av manifestverktyget innehåller annan information än manifestet som redan är inbäddat i binärfilen.

  4. Om manifestet som är inbäddat i binärfilen skiljer sig från manifestet som genereras av manifestverktyget, eller om binärfilen inte innehåller något inbäddat manifest, anropar Visual Studio länkaren en gång till för att bädda in den externa manifestfilen i binärfilen som en resurs.

  5. Om manifestet som är inbäddat i binärfilen är detsamma som manifestet som genereras av manifestverktyget fortsätter bygget till nästa byggsteg.

Manifestet bäddas in i den slutliga binära filen som en textresurs. Du kan visa den genom att öppna den slutliga binära filen som en fil i Visual Studio. För att säkerställa att manifestet pekar på rätt bibliotek följer du stegen som beskrivs i Förstå beroenden för ett Visual C++-program. Du kan också följa de förslag som beskrivs i artikeln Felsökning .

Manifestgenerering på kommandoraden

När du skapar C/C++-program från kommandoraden med hjälp av NMAKE eller liknande verktyg genereras manifestet när länkaren har bearbetat alla objektfiler och skapat den slutliga binära filen. Länkaren samlar in sammansättningsinformation som lagras i objektfilerna och kombinerar den här informationen till en slutlig manifestfil. Som standard genererar länkaren en fil med namnet <binary_name>.<extension>.manifest för att beskriva den slutliga binära filen. Länkaren kan bädda in en manifestfil i binärfilen genom att ange länkalternativet /MANIFEST:EMBED .

Det finns flera andra sätt att bädda in ett manifest i den slutliga binära filen, till exempel att använda manifestverktyget (mt.exe) eller kompilera manifestet i en resursfil. Du måste följa specifika regler när du bäddar in ett manifest för att aktivera funktioner som inkrementell länkning, signering och Redigera och Fortsätt. Dessa regler och andra alternativ beskrivs i nästa avsnitt.

Bädda in ett manifest i ett C/C++-program

Vi rekommenderar att du bäddar in manifestet för ditt program eller bibliotek i den slutliga binära filen. Den här metoden garanterar korrekt körningsbeteende i de flesta scenarier. Som standard försöker Visual Studio bädda in manifestet när det skapar ett projekt. Men om du skapar ditt program med hjälp av NMAKE måste du göra vissa ändringar i makefile. Det här avsnittet visar hur du ändrar makefiles så att manifestet bäddas in automatiskt i den slutliga binära filen.

Två metoder

Det finns två sätt att bädda in manifestet i ett program eller bibliotek.

  1. Om du inte gör en inkrementell version kan du bädda in manifestet direkt med hjälp av en kommandorad som liknar följande som ett steg efter bygget:

    mt.exe -manifest MyApp.exe.manifest -outputresource:MyApp.exe;1

    eller

    mt.exe -manifest MyLibrary.dll.manifest -outputresource:MyLibrary.dll;2

    Använd 1 för en EXE och 2 för en DLL.

  2. Om du gör en inkrementell version använder du följande steg:

    • Länka binärfilen för att generera MyApp.exe.manifest filen.

    • Konvertera manifestet till en resursfil.

    • Länka om (stegvis) för att bädda in manifestresursen i binärfilen.

Följande exempel visar hur du ändrar makefiles för att införliva båda teknikerna.

Makefiles (före)

Överväg NMAKE-skriptet för MyApp.exe, ett enkelt program som skapats från en fil:

# 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

Om skriptet körs oförändrat med Visual Studio skapas MyApp.exe framgångsrikt. Den skapar också den externa manifestfilen MyApp.exe.manifest, som används av operativsystemet för att läsa in beroende assemblys vid körning.

NMAKE-skriptet för MyLibrary.dll ser ut ungefär så här:

# 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 (efter)

Om du vill skapa med inbäddade manifest måste du göra fyra små ändringar i de ursprungliga makefilerna. MyApp.exe För makefile:

# 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.)

För MyLibrary.dll Makefile:

# 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.)

Makefiles innehåller nu två filer som gör det verkliga arbetet, makefile.inc och makefile.target.inc.

Skapa makefile.inc och kopiera följande innehåll till det:

# 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
####################################################

makefile.target.inc Skapa och kopiera nu följande innehåll till det:

# 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

Se även

Att skapa isolerade C/C++-program och sammansättningar sida vid sida
Begrepp för isolerade program och sammansättningar sida vid sida
Felsöka isolerade C/C++-program och sammansättningar sida vid sida
/INCREMENTAL (Länka inkrementellt)
/MANIFEST (Skapa sammansättningsmanifest sida vid sida)
Starka namnsammansättningar (sammansättningssignering) (C++/CLI)
Redigera och fortsätt