arquivos. netmodule como entrada de vinculador
Agora o link. exe aceita MSIL obj e. netmodules como entrada. O arquivo de saída produzido pelo vinculador será um assembly ou um. netmodule sem dependência de tempo de execução em qualquer uma da. obj ou. netmodules que fossem entrada para o vinculador.
. netmodules são criados pelo compilador 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 Visual Studio, use o /target:module opção de compilador.
Na maioria dos casos, você precisará passar para o vinculador do arquivo. obj de compilação da Visual C++ que criou o. netmodule, a menos que o. netmodule foi criado com /CLR (common Language Runtime Compilation). MSIL. netmodules usado como entrada para o vinculador deve ser a MSIL puro, que pode ser criada usando o Visual C++ compilador /clr:safe. Outros compiladores Visual Studio produzem módulos MSIL puros, por padrão.
Para obter informações sobre como chamar o vinculador a partir da linha de comando, consulte Sintaxe de linha de comando do vinculador e Definir o caminho e variáveis de ambiente para Builds de linha de comando.
Passando um. arquivo netmodule ou. dll para o vinculador que foi compilado pelo compilador Visual C++ com /clr ou com /clr:pure pode resultar em um erro de vinculador. For more information, see Escolha o formato. netmodule arquivos de entrada.
O vinculador aceita arquivos nativos. obj, além de arquivos. obj MSIL compilados com /clr, /clr:pure, ou /clr:safe. Ao passar .objs mistas na mesma compilação, o verifiability do arquivo de saída resultante, por padrão, será igual ao nível mais baixo de verifiability dos módulos de entrada. Por exemplo, se você passar um obj pura e seguro para o vinculador, o arquivo de saída será puro. / /CLRIMAGETYPE (Especifica o tipo de imagem do CLR)permite especificar um nível inferior de verifiability, se é que você precisa.
Se você tem um aplicativo é composto de dois ou mais assemblies e você deseja que o aplicativo estar contido em um assembly, você deve recompilar os assemblies e vincule-o .objs ou. netmodules para produzir um único assembly.
Você deve especificar um ponto de entrada usando / ENTRADA (símbolo de ponto de entrada) ao criar uma imagem executável.
Quando a vinculação com um obj MSIL ou. arquivo de netmodule, use / /LTCG (geração de código Link-time), caso contrário, quando o vinculador encontra a. obj MSIL ou. netmodule, ele será reiniciado o vínculo com /LTCG.
MSIL obj ou. netmodule arquivos também podem ser passados para CL.
Entrada MSIL obj ou. netmodule arquivos não podem ter recursos incorporados. Um recurso é incorporado em um arquivo de saída (módulo ou assembly) com / ASSEMBLYRESOURCE (incorporar um recurso gerenciado) a opção de vinculador ou com o /resource opção de compilador em outros compiladores de Visual Studio.
Ao executar a vinculação de MSIL, e se você não especificar também / /LTCG (geração de código Link-time), você verá uma mensagem informativa, emissão de relatórios que o link está reiniciando. Esta mensagem pode ser ignorada, mas ao melhorar o desempenho do vinculador com vinculação de MSIL, especificar explicitamente /LTCG.
Exemplo
No código C++ do bloco catch de um try correspondente será chamado para uma exceção do sistema não. No entanto, por padrão, o CLR quebra exceções do sistema não com RuntimeWrappedException. Quando um assembly é criado a partir do Visual C++ e os módulos não Visual C++ e desejar que um bloco catch no código C++ para ser chamado a partir de sua cláusula de try correspondente ao bloco try, que lança uma exceção de sistemas não, você deve adicionar o
atributo [assembly:System::Runtime::CompilerServices::RuntimeCompatibility(WrapNonExceptionThrows=false)] para o código-fonte para os módulos do C++ não.
// 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 booleano do atributo WrapNonExceptionThrows, você pode modificar a capacidade de capturar uma exceção do sistema não o código do Visual C++.
// 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#");
}
}
}