Procedure: Een assembly met meerdere bestanden bouwen

Artikel
06/04/2024

Notitie

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.

Notitie

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

Compileer alle bestanden die naamruimten bevatten waarnaar wordt verwezen door andere modules in de assembly in 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

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 optie /t: compiler 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.

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 optie /addmodule compiler 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

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 optie /t:module op omdat deze module in een toekomstige stap wordt toegevoegd aan een assembly. Geef de optie /addmodule 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.
Notitie

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
```
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 de volgende opdracht bij de opdrachtprompt:

naam van module al<module ...>>< /main:<method name>/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. De optie /main: geeft de naam van de methode op die het ingangspunt van de assembly is. De optie /out: geeft de naam op van het uitvoerbestand, dat assemblymetagegevens bevat. De optie /target: geeft aan dat de assembly een uitvoerbare consoletoepassingsbestand (.exe) is, een uitvoerbaar Windows-bestand (.win) of een bibliotheekbestand (.lib).

In het volgende voorbeeld maakt Al.exe een assembly die een uitvoerbare consoletoepassing is met de naam myAssembly.exe. De toepassing bestaat uit twee modules met de naam Client.netmodule en Stringer.netmodule, en het uitvoerbare bestand met de naam myAssembly.exe, dat alleen assemblymetagegevens bevat. Het ingangspunt van de assembly is de Main methode in de klasse MainClientApp, die zich in Client.dll bevindt.
```
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.

Delen via

Procedure: Een assembly met meerdere bestanden bouwen

Een assembly met meerdere bestanden maken

Zie ook

Feedback

Aanvullende resources