Arquivos .netmodule como entrada de vinculador
link.exe aceita agora MSIL .obj e .netmodules como entrada. O arquivo de saída gerada pelo vinculador será um assembly ou um .netmodule sem dependência de tempo de execução em qualquer um dos .obj ou de .netmodules que foram registrados no vinculador.
.netmodules são criados pelo compilador do Visual C++ com /LN (criar módulo MSIL) ou pelo vinculador com /NOASSEMBLY (criar um módulo MSIL). .objs sempre são criados em uma compilação do Visual C++. Para outros compiladores do Visual Studio, use a opção do compilador de /target:module .
Na maioria dos casos, você precisará passar para o vinculador o arquivo de .obj de compilação do Visual C++ que criou o .netmodule, a menos que o .netmodule foi criado com /clr (compilação do Common Language Runtime). MSIL .netmodules usado como entrada para o vinculador deve ser MSIL puro, que pode ser gerado pelo compilador do Visual C++ que usa /clr:safe. Outros compiladores do Visual Studio para gerenciar os módulos puros de MSIL por padrão.
Para obter informações sobre como invocar o vinculador de linha de comando, consulte Sintaxe da linha de comando do vinculador e Definindo as variáveis de caminho e ambiente para compilações de linha de comando.
Passe um .netmodule ou o arquivo .dll no vinculador que foi criado pelo compilador do Visual C++ com /clr ou com /clr:pure pode resultar em um erro do vinculador. Para obter mais informações, consulte Escolhendo o formato de arquivos de entrada .netmodule.
O vinculador aceita os arquivos nativos de .obj bem como os arquivos de .obj MSIL compilados com /clr, /clr:pure, ou /clr:safe. Ao passar .objs misto na mesma construção, a capacidade de verificação de arquivo de saída resultante, por padrão, será igual ao nível mais baixo de verificabilidade dos módulos de entrada. Por exemplo, se você passar um .obj seguro e puro ao vinculador, o arquivo de saída será puro. /CLRIMAGETYPE (especificar tipo de imagem CLR) permite especificar um nível inferior de verificabilidade, se isso for o que você precisa.
Se você tiver atualmente um aplicativo que esteja composta de duas ou mais assemblies e você quiser que o aplicativo ser contido em um assembly, você deverá recompilar os assemblies e depois vincule o .objs ou o .netmodules para gerar um único assembly.
Você deve especificar um ponto de entrada usando /ENTRY (símbolo do ponto de entrada) ao criar uma imagem executável.
Ao vincular a um arquivo de .obj MSIL ou de .netmodule, use /LTCG (geração de código do tempo de vinculação)caso contrário, quando o encontra o vinculador MSIL .obj ou .netmodule, ele reiniciará o link com /LTCG.
Os arquivos de .obj MSIL ou de .netmodule também podem ser passados a cl.exe.
A entrada MSIL .obj ou os arquivos de .netmodule não podem ter inserido recursos. Um recurso é inserido em um arquivo de saída (módulo) ou assembly com a opção do vinculador de /ASSEMBLYRESOURCE (inserir um recurso gerenciado) ou com a opção do compilador de /resource em outros compiladores do Visual Studio.
Ao executar MSIL que vincula, e também se você não especificar /LTCG (geração de código do tempo de vinculação), você verá um relatório de mensagem informativa que o link está reiniciando. Essa mensagem pode ser ignorada, mas para melhorar o desempenho do vinculador com o MSIL que vincula, especifique explicitamente /LTCG.
Exemplo
No código C++ o bloco de captura de uma tentativa correspondente não será invocado para uma exceção do sistema. No entanto, por padrão, CLR não envolve exceções do sistema com RuntimeWrappedException. Quando um assembly é criado do Visual C++ e não os módulos e você do Visual C++ desejam um bloco de captura no código C++ a ser invocado da cláusula correspondente da tentativa quando o bloco try não gerará uma exceção do sistema, você deve adicionar
[assembly:System::Runtime::CompilerServices::RuntimeCompatibility(WrapNonExceptionThrows=false)] atributo no código-fonte para os módulos não C++.
// MSIL_linking.cpp
// compile with: /c /clr
value struct V {};
ref struct MCPP {
static void Test() {
try {
throw (gcnew V);
}
catch (V ^) {
System::Console::WriteLine("caught non System exception in C++ source code file");
}
}
};
/*
int main() {
MCPP::Test();
}
*/
Alterando o valor booliano de atributo de WrapNonExceptionThrows, modifique a capacidade de código do Visual C++ de não capturar uma exceção do sistema.
// MSIL_linking_2.cs
// compile with: /target:module /addmodule:MSIL_linking.obj
// post-build command: link /LTCG MSIL_linking.obj MSIL_linking_2.netmodule /entry:MLinkTest.Main /out:MSIL_linking_2.exe /subsystem:console
using System.Runtime.CompilerServices;
// enable non System exceptions
[assembly:RuntimeCompatibility(WrapNonExceptionThrows=false)]
class MLinkTest {
public static void Main() {
try {
MCPP.Test();
}
catch (RuntimeWrappedException) {
System.Console.WriteLine("caught a wrapped exception in C#");
}
}
}