arquivos .netmodule sistema autônomo entrada do vinculador
link.exe agora aceita MSIL .obj e.netmodules sistema autônomo entrada.O arquivo de saída produzido pelo vinculador será um assembly ou um.netmodule com nenhuma dependência de time de execução em qualquer uma do .obj ou.netmodules eram de entrada para o vinculador.
.netmodules são criadas pelo compilador Visual C++ com /LN (criar MSIL módulo) 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 o /target:module opção do compilador.
Na maioria dos casos, você precisará passar para o vinculador arquivo .obj da compilação do Visual C++ que criou o.netmodule, a menos que o.netmodule foi criado com /CLR (Common linguagem tempo de execução compilação). MSIL.usado sistema autônomo entrada para o vinculador netmodules deve ser a MSIL puro, que pode ser produzido pelo compilador Visual C++ usando /clr:safe. Outros compiladores do 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 da 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 do vinculador. Para obter mais informações, consulte Escolha o formato de .netmodule arquivos de entrada.
O vinculador aceita arquivos .obj nativo, bem sistema autônomo MSIL .obj arquivos compilados com /clr, /clr:pure, ou /clr:safe. Ao passar .objs mistas na mesma compilaçã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 puro e seguras para o vinculador, o arquivo de saída será puro./ CLRIMAGETYPE (Especifica o tipo de imagem CLR) permite que você especificou um nível inferior verifiability, se esse for o que você precisa.
Se você tem atualmente um aplicativo que é composto de dois ou mais módulos (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.
Durante a vinculação com um .obj MSIL ou.arquivo netmodule, use / LTCG (geração de código link-time), caso contrário, quando o vinculador encontra .obj MSIL ou. netmodule, ele será reiniciado o vínculo com /LTCG.
Obj MSIL ou.netmodule arquivos também podem ser passados para cl.exe.
Entrada .obj MSIL ou.netmodule arquivos não podem ter recursos incorporadas.Um recurso é incorporado em um arquivo de saída (módulo ou assembly) com / ASSEMBLYRESOURCE (incorporar um recurso gerenciado) opção de vinculador ou com o /resource opção do compilador em outros compiladores do Visual Studio.
Ao executar a vinculação MSIL e se você não especificar também / LTCG (geração de código link-time), você verá uma mensagem informativa relatar que o link está sendo reiniciado. Esta mensagem pode ser ignorada, mas ao melhorar o desempenho do vinculador com MSIL vincular, especifique explicitamente /LTCG.
Exemplo
Código C++ o bloco catch de um bloco try correspondente será chamado para uma exceção não do sistema.No entanto, por padrão, o CLR encapsula sistema não exceções com RuntimeWrappedException. Quando um assembly é criado do Visual C++ e módulos do Visual C++ não e você desejar que um bloco catch no código C++ para ser chamado na sua cláusula try correspondente ao bloco try lança uma exceção não sistema, você deve adicionar o
atributo [assembly:sistema::tempo de execução::CompilerServices::RuntimeCompatibility(WrapNonExceptionThrows=false)] o código-fonte para os módulos de 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 do atributo WrapNonExceptionThrows booliano, você pode modificar a capacidade do código do Visual C++ para detectar uma exceção de sistema não.
// 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#");
}
}
}
caught non System exception in C++ source code file