Condividi tramite

.netmodule file come input del linker

  • Articolo

link.exe accetta MSIL .obj e .netmodule i file come input. Il file di output prodotto dal linker è un assembly o un .netmodule file senza dipendenze in fase di esecuzione da uno qualsiasi dei .obj file o .netmodule che erano input per il linker.

Osservazioni:

.netmodulei file vengono creati dal compilatore MSVC con /LN (modulo Create MSIL) o dal linker con /NOAS edizione Standard MBLY (Create a MSIL Module). .obj i file vengono sempre creati in una compilazione C++. Per altri compilatori di Visual Studio, usare l'opzione del compilatore /target:module.

Il linker deve essere passato al .obj file dalla compilazione C++ che ha creato ..netmodule Il passaggio di un .netmodule oggetto non è più supportato perché le opzioni del compilatore /clr:pure e /clr:safe sono deprecate in Visual Studio 2015 e non supportate in Visual Studio 2017 e versioni successive.

Per informazioni su come richiamare il linker dalla riga di comando, vedere sintassi della riga di comando del linker e Usare il set di strumenti MSVC dalla riga di comando.

Il passaggio di un .netmodule file o .dll al linker compilato dal compilatore MSVC con /clr può generare un errore del linker. Per altre informazioni, vedere Scelta del formato dei file dinetmodule input.

Il linker accetta sia i file nativi .obj che i file MSIL .obj compilati con /clr. È possibile passare file misti .obj nella stessa compilazione. La verifica predefinita del file di output risultante corrisponde alla verificabilità del modulo di input più basso.

È possibile modificare un'applicazione composta da due o più assembly in modo che siano contenuti in un assembly. Ricompilare le origini degli assembly e quindi collegare i file o .netmodule i .obj file per produrre un singolo assembly.

Specificare un punto di ingresso usando /ENTRY (simbolo punto di ingresso) durante la creazione di un'immagine eseguibile.

Quando si esegue il collegamento con un file o MSIL.obj, usare /LTCG (generazione di codice in fase di collegamento), in caso contrario, quando il linker rileva MSIL .obj o .netmodule, riavvia il collegamento con /LTCG..netmodule Verrà visualizzato un messaggio informativo che indica che il collegamento viene riavviato. È possibile ignorare questo messaggio, ma per migliorare le prestazioni del linker, specificare in modo esplicito /LTCG.

I file o .netmodule MSIL .obj possono anche essere passati a cl.exe.

I file o .netmodule MSIL .obj di input non possono avere risorse incorporate. Incorporare le risorse in un modulo di output o in un file di assembly usando l'opzione del linker /AS edizione Standard MBLYRESOURCE (Incorpora una risorsa gestita). In alternativa, usare l'opzione /resource compiler in altri compilatori di Visual Studio.

Esempi

Nel codice C++ il catch blocco di un oggetto corrispondente try verrà richiamato per un'eccezione nonSystem . Tuttavia, per impostazione predefinita, CLR esegue il wrapping di eccezioni nonSystem con RuntimeWrappedException. Quando un assembly viene creato da moduli C++ e non C++ e si vuole richiamare un catch blocco nel codice C++ dalla clausola corrispondente try quando il try blocco genera un'eccezioneSystem diversa, è necessario aggiungere l'attributo [assembly:System::Runtime::CompilerServices::RuntimeCompatibility(WrapNonExceptionThrows=false)] al codice sorgente per i moduli non 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();
}
*/

Modificando il Boolean valore dell'attributo WrapNonExceptionThrows , si modifica la capacità del codice C++ di intercettare un'eccezioneSystem non.

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

Vedi anche