Beispiel für eine Mehrfachdateiassembly

In diesem Abschnitt wird an einem vollständigen Beispiel Schritt für Schritt erläutert, wie Sie eine Mehrfachdateiassembly erstellen können.

Schritt 1 – Kompilieren von Dateien mit Namespaces, auf die von anderen Dateien verwiesen wird

Dieses Beispiel beginnt mit einfachem Code für die Datei Stringer, die über einen Namespace namens myStringer mit einer Klasse namens Stringer verfügt. Die Stringer-Klasse enthält die StringerMethod-Methode, die eine einzelne Zeile auf der Konsole ausgibt.

' Assembly building example in the .NET Framework SDK.
Imports System
Namespace myStringer 
   Public Class Stringer
      Public Sub StringerMethod() 
         Console.WriteLine("This is a line from StringerMethod.")
      End Sub
   End Class
End Namespace
[C#]
// Assembly building example in the .NET Framework SDK.
using System;
namespace myStringer 
   {
   public class Stringer
      { 
      public void StringerMethod() 
         {
         System.Console.WriteLine("This is a line from StringerMethod.");
         }
      }
   }

Verwenden Sie folgenden Befehl, um diesen Code zu kompilieren:

vbc /t:module Stringer.vb
[C#]
csc /t:module Stringer.cs

Durch die Compileroption /t: in Verbindung mit dem Parameter module wird die Datei als Modul kompiliert, nicht als Assembly. Der Compiler erzeugt ein Modul namens Stringer.netmodule, das anschließend zu einer Assembly hinzugefügt werden kann.

Schritt 2 – Kompilieren von Modulen, die Verweise auf andere Module enthalten

In diesem Schritt kommt die Compileroption /addmodule zum Einsatz. Im vorliegenden Beispiel verfügt ein Codemodul namens Client über die Main-Methode als Einstiegspunkt. Diese verweist wiederum auf eine Methode im Modul Stringer.dll, das in Schritt 1 erstellt wurde.

Der folgende Beispielcode ist der Code für Client.

Imports System
Imports myStringer  'The namespace created in Stringer.netmodule.
Class MainClientApp
   ' Shared method Main is the entry point method.
   Public Shared Sub Main()
      Dim myStringInstance As New Stringer()
      Console.WriteLine("Client code executes")
      'myStringComp.Stringer()
      myStringInstance.StringerMethod()
   End Sub
End Class
[C#]
using System;
using myStringer; //The namespace created in Stringer.netmodule.
class MainClientApp 
{
   // Static method Main is the entry point method.
   public static void Main() 
   { 
      Stringer myStringInstance = new Stringer();
      Console.WriteLine("Client code executes");
      //myStringComp.Stringer();
      myStringInstance.StringerMethod();
   }
}

Verwenden Sie folgenden Befehl, um diesen Code zu kompilieren:

vbc /addmodule:Stringer.netmodule /t:module Client.vb
[C#]
csc /addmodule:Stringer.netmodule /t:module Client.cs

Verwenden Sie die Option /t:module, da dieses Modul in einem späteren Schritt zu einer Assembly hinzugefügt wird. Legen Sie die Option /addmodule fest, da der Code in Client auf einen Namespace verweist, der vom Code in Stringer.netmodule erzeugt wurde. Der Compiler erzeugt ein Modul namens Client.netmodule, das einen Verweis auf ein anderes Modul, Stringer.netmodule, enthält.

Hinweis   C#- und Visual Basic-Compiler unterstützen das direkte Erstellen von Mehrfachdateiassemblies unter Verwendung der beiden folgenden unterschiedlichen Syntaxformen.

• Zwei Kompilierungen erzeugen eine aus zwei Dateien bestehende Assembly:

  vbc /t:module Stringer.vb
  vbc Client.vb /addmodule:Stringer.netmodule
  [C#]
  csc /t:module Stringer.cs
  csc Client.cs /addmodule:Stringer.netmodule
  

• Eine Kompilierung erzeugt eine aus zwei Dateien bestehende Assembly:

  vbc /out:Stringer.netmodule Stringer.vb /out:Client.exe Client.vb
  [C#]
  csc /out:Client.exe Client.cs /out:Stringer.netmodule Stringer.cs
  

Schritt 3 – Erstellen einer Mehrfachdateiassembly mit Hilfe des Assemblylinkers

Sie können mit dem Assembly Linker-Tool (Al.exe) aus einer Auflistung von kompilierten Codemodulen eine Assembly erzeugen.

So erstellen Sie mit Hilfe des Assemblylinkers eine Mehrfachdateiassembly

• Geben Sie an der Eingabeaufforderung folgenden Befehl ein:

  al <Modulname> <Modulname> ... /main:<Methodenname> /out:<Dateiname> /target:<Assemblydateityp>

  In diesem Befehl bezeichnen die Modulname-Argumente die Namen aller Module, die in der Assembly enthalten sein sollen. Die Option /main: gibt den Methodennamen an, der den Einstiegspunkt der Assembly darstellt. Die Option /out: gibt den Namen der Ausgabedatei an, die Assemblymetadaten enthält. Die Option /target: gibt an, dass die Assembly eine ausführbare Datei für eine Konsolenanwendung (.exe), eine ausführbare Windows-Datei (.win) oder eine Bibliothek ist (.lib).

Im folgenden Beispiel erstellt Al.exe eine Assembly namens myAssembly.exe, die eine ausführbare Datei für eine Konsolenanwendung ist. Die Anwendung besteht aus zwei Modulen, Client.netmodule und Stringer.netmodule, sowie der ausführbaren Datei myAssembly.exe, die ausschließlich Assemblymetadaten enthält. Der Einstiegspunkt der Assembly ist die Main-Methode in der MainClientApp-Klasse, die sich in der Datei Client.dll befindet.

al Client.netmodule Stringer.netmodule /main:MainClientApp.Main /out:myAssembly.exe /target:exe 

Sie können das MSIL Disassembler-Tool (Ildasm.exe) verwenden, um den Inhalt einer Assembly zu untersuchen oder um zu bestimmen, ob es sich bei einer Datei um eine Assembly oder ein Modul handelt.

Siehe auch

Erstellen von Assemblies | Anzeigen von Assemblyinhalten | So sucht Common Language Runtime nach Assemblies | Erstellen einer Mehrfachdateiassembly