Partilhar via

Noções básicas sobre a geração de manifesto para programas C/C++

Um manifesto é um documento XML que identifica exclusivamente um assembly. Ele contém informações usadas para vinculação e ativação, como classes COM, interfaces e bibliotecas de tipos. Um manifesto pode ser um arquivo XML externo ou um recurso incorporado dentro de um aplicativo ou assembly. O manifesto de um aplicativo isolado é usado para gerenciar os nomes e versões de assemblies compartilhados lado a lado aos quais o aplicativo deve se vincular em tempo de execução. O manifesto de um assembly lado a lado especifica suas dependências em nomes, versões, recursos e outros assemblies.

Há duas maneiras de criar um manifesto para uma aplicação isolada ou um conjunto paralelo. Primeiro, o autor da assemblagem pode criar manualmente um arquivo de manifesto seguindo as regras e os requisitos de nomenclatura. Para obter mais informações, consulte Referência de arquivos de manifesto. Como alternativa, se um programa depende apenas de assemblies Microsoft C++ (MSVC), como CRT, MFC, ATL ou outros, o vinculador pode gerar um manifesto automaticamente.

Os cabeçalhos das bibliotecas MSVC contêm informações de assembly e, quando as bibliotecas são incluídas no código do aplicativo, essas informações de assembly são usadas pelo vinculador para formar um manifesto para o binário final. Por padrão, o vinculador não incorpora o arquivo de manifesto dentro do binário. Ter um manifesto como um arquivo externo pode não funcionar para todos os cenários. Por exemplo, é recomendável que os assemblies privados tenham manifestos incorporados. Em compilações de linha de comando, como aquelas que usam NMAKE para criar código, você pode usar a /MANIFEST:EMBED opção vinculador para incorporar o manifesto. Como alternativa, um manifesto pode ser incorporado usando a ferramenta de manifesto. Para obter mais informações, consulte Geração de manifesto na linha de comandos. Quando você cria no Visual Studio, um manifesto pode ser incorporado definindo uma propriedade para a ferramenta de manifesto na caixa de diálogo Propriedades do projeto , conforme descrito na próxima seção.

Geração de manifesto no Visual Studio

Você pode instruir o Visual Studio a criar um ficheiro de manifesto para um projeto específico na janela de diálogo Páginas de propriedades do projeto. Em Propriedades de Configuração, selecione Vinculador>Arquivo de Manifesto>Gerar Manifesto. Por padrão, as propriedades dos novos projetos são definidas para gerar um arquivo de manifesto. No entanto, é possível desativar a geração do manifesto para um projeto usando a propriedade Generate Manifest do projeto. Quando essa propriedade é definida como Sim, o manifesto para o projeto é gerado. Caso contrário, o vinculador ignora as informações do assembly ao resolver dependências do código do aplicativo e não gera o manifesto.

O sistema de compilação no Visual Studio permite que o manifesto seja incorporado no arquivo de aplicativo binário final ou gerado como um arquivo externo. Esse comportamento é controlado pela opção Incorporar manifesto na caixa de diálogo Propriedades do projeto . Para definir essa propriedade, abra o nó Ferramenta de manifesto e selecione Entrada e saída. Se o manifesto não estiver incorporado, ele será gerado como um arquivo externo e salvo no mesmo diretório do binário final. Se o manifesto for incorporado, o Visual Studio incorporará os manifestos finais usando o seguinte processo:

  1. Depois que o código-fonte é compilado em arquivos de objeto, o vinculador coleta informações de assembly dependentes. Enquanto vincula o binário final, o vinculador gera um manifesto intermediário que é usado posteriormente para gerar o manifesto final.

  2. Depois que o manifesto intermediário e a vinculação forem concluídos, a ferramenta de manifesto mesclará um manifesto final e o salvará como um arquivo externo.

  3. Em seguida, o sistema de compilação do projeto deteta se o manifesto gerado pela ferramenta de manifesto contém informações diferentes do manifesto já incorporado no binário.

  4. Se o manifesto incorporado no binário for diferente do manifesto gerado pela ferramenta de manifesto ou se o binário não contiver um manifesto incorporado, o Visual Studio invocará o vinculador mais uma vez para incorporar o arquivo de manifesto externo dentro do binário como um recurso.

  5. Se o manifesto incorporado no binário for o mesmo que o manifesto gerado pela ferramenta de manifesto, a compilação continuará para as próximas etapas de compilação.

O manifesto é incorporado dentro do binário final como um recurso de texto. Você pode exibi-lo abrindo o binário final como um arquivo no Visual Studio. Para garantir que o manifesto aponte para as bibliotecas corretas, siga as etapas descritas em Compreendendo as dependências de um aplicativo Microsoft C++. Ou siga as sugestões descritas no artigo Solução de problemas .

Gerar manifestos na linha de comando

Quando você cria aplicativos C/C++ a partir da linha de comando usando NMAKE ou ferramentas semelhantes, o manifesto é gerado depois que o vinculador processou todos os arquivos de objeto e criou o binário final. O ligador recolhe informações de montagem armazenadas nos ficheiros de objeto e combina essas informações num ficheiro de manifesto final. Por padrão, o vinculador gera um arquivo nomeado <binary_name>.<extension>.manifest para descrever o binário final. O vinculador pode incorporar um ficheiro de manifesto dentro do binário ao especificar a opção de vinculador /MANIFEST:EMBED.

Há várias outras maneiras de incorporar um manifesto dentro do binário final, como usar a ferramenta Manifesto (mt.exe) ou compilar o manifesto em um arquivo de recurso. Você deve seguir regras específicas ao incorporar um manifesto para habilitar recursos como vinculação incremental, assinatura e Editar e Continuar. Essas regras e outras opções são discutidas na próxima seção.

Como incorporar um manifesto dentro de um aplicativo C/C++

Recomendamos que você incorpore o manifesto do seu aplicativo ou biblioteca dentro do binário final. Essa abordagem garante o comportamento correto do tempo de execução na maioria dos cenários. Por padrão, o Visual Studio tenta incorporar o manifesto quando cria um projeto. No entanto, se você compilar seu aplicativo usando NMAKE, você terá que fazer algumas alterações no makefile. Esta seção mostra como alterar os makefiles para que ele incorpore automaticamente o manifesto dentro do binário final.

Duas abordagens

Há duas maneiras de incorporar o manifesto dentro de um aplicativo ou biblioteca.

  1. Se você não estiver fazendo uma compilação incremental, poderá incorporar diretamente o manifesto usando uma linha de comando semelhante à seguinte como uma etapa pós-compilação:

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

    ou

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

    Use 1 para um EXE e 2 para uma DLL.

  2. Se estiveres a realizar uma construção incremental, segue os seguintes passos:

    • Vincule o binário para gerar o MyApp.exe.manifest arquivo.

    • Converta o manifesto em um arquivo de recurso.

    • Revincule (incrementalmente) para incorporar o recurso de manifesto no binário.

Os exemplos a seguir mostram como alterar makefiles para incorporar ambas as técnicas.

Makefiles (Antes)

Considere o script NMAKE para MyApp.exe, um aplicativo simples construído a partir de um arquivo:

# 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

Se esse script for executado inalterado com o Visual Studio, ele criará com êxito MyApp.exe. Ele também cria o arquivo de manifesto externo MyApp.exe.manifest, para que o sistema operacional carregue os assemblies dependentes durante o tempo de execução.

O script NMAKE para MyLibrary.dll é semelhante:

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

Para construir com manifestos incorporados, você precisa fazer quatro pequenas alterações nos makefiles originais. Para o MyApp.exe 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.)

Para o 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.)

Os makefiles agora incluem dois arquivos que fazem o trabalho real, makefile.inc e makefile.target.inc.

Crie makefile.inc e copie o seguinte conteúdo para ele:

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

Agora crie makefile.target.inc e copie o seguinte conteúdo para ele:

# 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

Ver também

Construção de aplicações isoladas C/C++ e conjuntos lado a lado
Conceitos de aplicações isoladas e montagens lado a lado
Solução de problemas de aplicativos isolados C/C++ e assemblies lado a lado
/INCREMENTAL (Link incrementalmente)
/MANIFEST (Criar manifesto de assembly lado a lado)
Assemblies de Nome Forte (assinatura de assemblies) (C++/CLI)
Editar e continuar

  • Last updated on