Gör så här: Skapa en sammansättning med flera filer

Artikel
10/06/2023

Den här artikeln beskriver hur du skapar en sammansättning med flera filer och innehåller kod som illustrerar varje steg i proceduren.

Kommentar

Visual Studio IDE för C# och Visual Basic kan bara användas för att skapa enfilssammansättningar. Om du vill skapa flerfilssammansättningar måste du använda kommandoradskompilatorerna eller Visual Studio med Visual C++. Multifile-sammansättningar stöds endast av .NET Framework.

Skapa en sammansättning med flera filer

Kompilera alla filer som innehåller namnområden som refereras av andra moduler i sammansättningen till kodmoduler. Standardtillägget för kodmoduler är .netmodule.

Anta till exempel att Stringer filen har ett namnområde med namnet myStringer, som innehåller en klass med namnet Stringer. Klassen Stringer innehåller en metod som heter StringerMethod som skriver en enda rad till konsolen.

// Assembly building example in the .NET Framework.
using namespace System;

namespace myStringer
{
    public ref class Stringer
    {
    public:
        void StringerMethod()
        {
            System::Console::WriteLine("This is a line from StringerMethod.");
        }
    };
}

// Assembly building example in the .NET Framework.
using System;

namespace myStringer
{
    public class Stringer
    {
        public void StringerMethod()
        {
            System.Console.WriteLine("This is a line from StringerMethod.");
        }
    }
}

' Assembly building example in the .NET Framework.
Namespace myStringer
    Public Class Stringer
        Public Sub StringerMethod()
            System.Console.WriteLine("This is a line from StringerMethod.")
        End Sub
    End Class
End Namespace

Använd följande kommando för att kompilera den här koden:
```
cl /clr:pure /LN Stringer.cpp
```
```
csc /t:module Stringer.cs
```
```
vbc /t:module Stringer.vb
```
Om du anger modulparametern med kompileringsalternativet /t: anger du att filen ska kompileras som en modul i stället för som en sammansättning. Kompilatorn skapar en modul med namnet Stringer.netmodule, som kan läggas till i en sammansättning.

Kompilera alla andra moduler med hjälp av de nödvändiga kompilatoralternativen för att ange de andra modulerna som refereras till i koden. Det här steget använder kompileringsalternativet /addmodule .

I följande exempel har en kodmodul med namnet Client en startpunktsmetod Main som refererar till en metod i modulen Stringer.netmodule som skapades i steg 1.

#using "Stringer.netmodule"

using namespace System;
using namespace myStringer; //The namespace created in Stringer.netmodule.

ref class MainClientApp
{
    // Static method Main is the entry point method.
public:
    static void Main()
    {
        Stringer^ myStringInstance = gcnew Stringer();
        Console::WriteLine("Client code executes");
        myStringInstance->StringerMethod();
    }
};

int main()
{
    MainClientApp::Main();
}

using System;
using myStringer;

class MainClientApp
{
    // Static method Main is the entry point method.
    public static void Main()
    {
        Stringer myStringInstance = new Stringer();
        Console.WriteLine("Client code executes");
        myStringInstance.StringerMethod();
    }
}

Imports myStringer

Class MainClientApp
    ' Static method Main is the entry point method.
    Public Shared Sub Main()
        Dim myStringInstance As New Stringer()
        Console.WriteLine("Client code executes")
        myStringInstance.StringerMethod()
    End Sub
End Class

Använd följande kommando för att kompilera den här koden:
```
cl /clr:pure /FUStringer.netmodule /LN Client.cpp
```
```
csc /addmodule:Stringer.netmodule /t:module Client.cs
```
```
vbc /addmodule:Stringer.netmodule /t:module Client.vb
```
Ange alternativet /t:module eftersom den här modulen läggs till i en sammansättning i ett framtida steg. Ange alternativet /addmodule eftersom koden i Klienten refererar till ett namnområde som skapats av koden i Stringer.netmodule. Kompilatorn skapar en modul med namnet Client.netmodule som innehåller en referens till en annan modul, Stringer.netmodule.
Kommentar

Kompilatorerna C# och Visual Basic har stöd för att skapa flerfilssammansättningar direkt med hjälp av följande två olika syntaxer.

Två kompileringar skapar en sammansättning med två filer:
```
cl /clr:pure /LN Stringer.cpp
cl /clr:pure Client.cpp /link /ASSEMBLYMODULE:Stringer.netmodule
```
```
csc /t:module Stringer.cs
csc Client.cs /addmodule:Stringer.netmodule
```
```
vbc /t:module Stringer.vb
vbc Client.vb /addmodule:Stringer.netmodule
```
En kompilering skapar en sammansättning med två filer:
```
cl /clr:pure /LN Stringer.cpp
cl /clr:pure Client.cpp /link /ASSEMBLYMODULE:Stringer.netmodule
```
```
csc /out:Client.exe Client.cs /out:Stringer.netmodule Stringer.cs
```
```
vbc /out:Client.exe Client.vb /out:Stringer.netmodule Stringer.vb
```
Använd Assembly Linker (Al.exe) för att skapa utdatafilen som innehåller sammansättningsmanifestet. Den här filen innehåller referensinformation för alla moduler eller resurser som ingår i sammansättningen.

Skriv följande kommando i kommandotolken:

al<module name><module name ...> /main:<method name>/out:<file name>/target:<assembly file type>

I det här kommandot anger argumenten för modulnamn namnet på varje modul som ska ingå i sammansättningen. Alternativet /main: anger metodnamnet som är sammansättningens startpunkt. Alternativet /out: anger namnet på utdatafilen, som innehåller sammansättningsmetadata. Alternativet /target: anger att sammansättningen är en körbar fil för konsolprogram (.exe), en körbar Windows-fil (.win) eller en biblioteksfil (.lib).

I följande exempel skapar Al.exe en sammansättning som är en körbar konsolapp med namnet myAssembly.exe. Programmet består av två moduler som kallas Client.netmodule och Stringer.netmodule och den körbara filen som heter myAssembly.exe, som endast innehåller sammansättningsmetadata. Startpunkten för sammansättningen är Main metoden i klassen MainClientApp, som finns i Client.dll.
```
al Client.netmodule Stringer.netmodule /main:MainClientApp.Main /out:myAssembly.exe /target:exe
```
Du kan använda IL Disassembler (Ildasm.exe) för att undersöka innehållet i en sammansättning eller avgöra om en fil är en sammansättning eller en modul.

Share via

Gör så här: Skapa en sammansättning med flera filer

Skapa en sammansättning med flera filer

Se även

Feedback

Ytterligare resurser