Dela via

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

Anmärkning

Den här artikeln är specifik för .NET Framework. Det gäller inte för nyare implementeringar av .NET, inklusive .NET 6 och senare versioner.

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

Anmärkning

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

  1. 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

  2. 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.

  3. 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. I det här steget används kompilatoralternativet /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

  4. 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 kommer att läggas 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.

    Anmärkning

    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

  5. 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.

    I kommandotolken skriver du följande kommando:

    al < modulnamn><modulnamn> … /main: < metodnamn>/out:<filnamn>/target:<sammansättningsfiltyp>

    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 konsolprogramfil (.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 med namnet 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.

Se även

  • Last updated on