Instrukcje: tworzenie zestawu wieloplikowego

  • Artykuł

W tym artykule wyjaśniono, jak utworzyć zestaw wieloplikowy i zawiera kod ilustrujący każdy krok procedury.

Uwaga

Środowisko IDE programu Visual Studio dla języka C# i Visual Basic może służyć tylko do tworzenia zestawów z jednym plikiem. Jeśli chcesz utworzyć zestawy wieloplikowe, musisz użyć kompilatorów wiersza polecenia lub programu Visual Studio z programem Visual C++. Zestawy wieloplikowe są obsługiwane tylko przez program .NET Framework.

Tworzenie zestawu wieloplikowego

  1. Skompiluj wszystkie pliki zawierające przestrzenie nazw, do których odwołuje się inne moduły w zestawie, do modułów kodu. Domyślnym rozszerzeniem modułów kodu jest .netmodule.

    Załóżmy na przykład, że Stringer plik ma przestrzeń nazw o nazwie , która zawiera klasę o nazwie myStringerStringer. Klasa Stringer zawiera metodę o nazwie StringerMethod , która zapisuje pojedynczy wiersz w konsoli.

    // 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. Użyj następującego polecenia, aby skompilować ten kod:

    cl /clr:pure /LN Stringer.cpp

    csc /t:module Stringer.cs

    vbc /t:module Stringer.vb

    Określenie parametru modułu z /t: opcja kompilatora wskazuje, że plik powinien być kompilowany jako moduł, a nie jako zestaw. Kompilator tworzy moduł o nazwie Stringer.netmodule, który można dodać do zestawu.

  3. Skompiluj wszystkie inne moduły przy użyciu niezbędnych opcji kompilatora, aby wskazać inne moduły, do których odwołuje się kod. W tym kroku jest używana opcja kompilatora /addmodule .

    W poniższym przykładzie moduł kodu o nazwie Client ma metodę punktu Main wejścia, która odwołuje się do metody w module Stringer.netmodule utworzonym w kroku 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. Użyj następującego polecenia, aby skompilować ten kod:

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

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

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

    Określ opcję /t:module, ponieważ ten moduł zostanie dodany do zestawu w przyszłym kroku. Określ opcję /addmodule, ponieważ kod w kliencie odwołuje się do przestrzeni nazw utworzonej przez kod w stringer.netmodule. Kompilator tworzy moduł o nazwie Client.netmodule , który zawiera odwołanie do innego modułu Stringer.netmodule.

    Uwaga

    Kompilatory języka C# i Visual Basic obsługują bezpośrednie tworzenie zestawów wieloplikowych przy użyciu następujących dwóch różnych składni.

    Dwie kompilacje tworzą zestaw dwóch plików:

    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

    Jedna kompilacja tworzy zestaw z dwoma plikami:

    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. Użyj konsolidatora zestawów (Al.exe), aby utworzyć plik wyjściowy zawierający manifest zestawu. Ten plik zawiera informacje referencyjne dotyczące wszystkich modułów lub zasobów, które są częścią zestawu.

    W wierszu polecenia wpisz następujące polecenie:

    al<nazwa modułu nazwa><> modułu ... /main:<method name>/out:<file name>/target:<assembly file type>

    W tym poleceniu argumenty nazwy modułu określają nazwę każdego modułu do uwzględnienia w zestawie. / main: opcja określa nazwę metody, która jest punktem wejścia zestawu. / out: opcja określa nazwę pliku wyjściowego, który zawiera metadane zestawu. /target: opcja określa, że zestaw jest plikiem wykonywalnym aplikacji konsolowej (.exe), plikiem wykonywalnym systemu Windows (win) lub plikiem biblioteki (lib).

    W poniższym przykładzie Al.exe tworzy zestaw, który jest plikiem wykonywalnym aplikacji konsolowej o nazwie myAssembly.exe. Aplikacja składa się z dwóch modułów o nazwie Client.netmodule i Stringer.netmodule oraz pliku wykonywalnego o nazwie myAssembly.exe, który zawiera tylko metadane zestawu. Punktem wejścia zestawu jest Main metoda w klasie MainClientApp, która znajduje się w Client.dll.

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

    Można użyć dezasemblera IL (Ildasm.exe), aby sprawdzić zawartość zestawu lub określić, czy plik jest zestawem, czy modułem.

Zobacz też