Delen via

Hoe: Een assembly met meerdere bestanden bouwen

Opmerking

Dit artikel is specifiek voor .NET Framework. Dit geldt niet voor nieuwere implementaties van .NET, waaronder .NET 6 en nieuwere versies.

In dit artikel wordt uitgelegd hoe u een assembly met meerdere bestanden maakt en code biedt die elke stap in de procedure illustreert.

Opmerking

De Visual Studio IDE voor C# en Visual Basic kunnen alleen worden gebruikt om assembly's met één bestand te maken. Als u assembly's met meerdere bestanden wilt maken, moet u de opdrachtregelcompilers of Visual Studio gebruiken met Visual C++. Assembly's met meerdere bestanden worden alleen ondersteund door .NET Framework.

Een assembly met meerdere bestanden maken

  1. Compileer alle bestanden die naamruimten bevatten waar andere modules in de assembly naar verwijzen tot codemodules. De standaardextensie voor codemodules is .netmodule.

    Stel dat het Stringer bestand een naamruimte heeft met de naamruimte myStringer, die een klasse bevat met de naam Stringer. De Stringer klasse bevat een methode die wordt aangeroepen StringerMethod om één regel naar de console te schrijven.

    // 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. Gebruik de volgende opdracht om deze code te compileren:

    cl /clr:pure /LN Stringer.cpp

    csc /t:module Stringer.cs

    vbc /t:module Stringer.vb

    Het opgeven van de moduleparameter met de /t: compileroptie geeft aan dat het bestand moet worden gecompileerd als een module in plaats van als assembly. De compiler produceert een module met de naam Stringer.netmodule, die kan worden toegevoegd aan een assembly.

  3. Compileer alle andere modules met behulp van de benodigde compileropties om de andere modules aan te geven waarnaar in de code wordt verwezen. In deze stap wordt de /addmodule compileroptie gebruikt.

    In het volgende voorbeeld heeft een codemodule met de naam Client een invoerpuntmethode Main die verwijst naar een methode in de module Stringer.netmodule die in stap 1 is gemaakt.

    #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. Gebruik de volgende opdracht om deze code te compileren:

    cl /clr:pure /FUStringer.netmodule /LN Client.cpp

    csc /addmodule:Stringer.netmodule /t:module Client.cs

    vbc /addmodule:Stringer.netmodule /t:module Client.vb

    Geef de /t:module optie op omdat deze module in een toekomstige stap wordt toegevoegd aan een assembly. Geef de /addmodule optie op omdat de code in Client verwijst naar een naamruimte die is gemaakt door de code in Stringer.netmodule. De compiler produceert een module met de naam Client.netmodule die een verwijzing naar een andere module, Stringer.netmodule, bevat.

    Opmerking

    De C#- en Visual Basic-compilers ondersteunen het rechtstreeks maken van assembly's met meerdere bestanden met behulp van de volgende twee verschillende syntaxis.

    Twee compilaties maken een assembly met twee bestanden:

    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

    Met één compilatie wordt een assembly met twee bestanden gemaakt:

    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. Gebruik de Assembly Linker (Al.exe) om het uitvoerbestand te maken dat het assemblymanifest bevat. Dit bestand bevat referentie-informatie voor alle modules of resources die deel uitmaken van de assembly.

    Typ bij de opdrachtprompt de volgende opdracht:

    al < modulenaam><modulenaam> … /main: < methodenaam>/out:<bestandsnaam>/target:<assembly bestandstype>

    In deze opdracht geven de argumenten van de modulenaam de naam op van elke module die in de assembly moet worden opgenomen. Met /main: de optie geeft u de methodenaam op die het ingangspunt van de assembly is. Met de /out: optie geeft u de naam op van het uitvoerbestand, dat assemblymetagegevens bevat. De /target: optie geeft aan dat de assembly een uitvoerbaar consoletoepassingsbestand (.exe) is, een uitvoerbaar Windows-bestand (.win) of een bibliotheekbestand (.lib).

    In het volgende voorbeeld maaktAl.exe een assembly die een uitvoerbare consoletoepassing is met de naammyAssembly.exe. De toepassing bestaat uit twee modules met de naam Client.netmodule en Stringer.netmodule, en het uitvoerbare bestand myAssembly.exe, dat alleen assemblymetagegevens bevat. Het ingangspunt van de assembly is de Main methode in de klasse MainClientApp, die zich in Client.dllbevindt.

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

    U kunt IL Disassembler (Ildasm.exe) gebruiken om de inhoud van een assembly te onderzoeken of om te bepalen of een bestand een assembly of een module is.

Zie ook

  • Last updated on