Compartir vía

Cómo: Compilar un ensamblado de varios archivos

Nota:

Este artículo es específico de .NET Framework. No se aplica a implementaciones más recientes de .NET, incluidas .NET 6 y versiones posteriores.

En este artículo se explica cómo crear un ensamblado de varios archivos y se proporciona código que ilustra cada paso del procedimiento.

Nota:

El IDE de Visual Studio para C# y Visual Basic solo se pueden usar para crear ensamblados de un solo archivo. Si desea crear ensamblados de varios archivos, debe usar los compiladores de línea de comandos o Visual Studio con Visual C++. Los ensamblados de varios archivos solo son compatibles con .NET Framework.

Creación de un ensamblado de varios archivos

  1. Compile todos los archivos que contienen espacios de nombres a los que hacen referencia otros módulos del ensamblado en módulos de código. La extensión predeterminada para los módulos de código es .netmodule.

    Por ejemplo, supongamos que el Stringer archivo tiene un espacio de nombres denominado myStringer, que incluye una clase denominada Stringer. La Stringer clase contiene un método denominado StringerMethod que escribe una sola línea en la consola.

    // 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. Use el siguiente comando para compilar este código:

    cl /clr:pure /LN Stringer.cpp

    csc /t:module Stringer.cs

    vbc /t:module Stringer.vb

    Especificar el parámetro de módulo con la /t: opción del compilador indica que el archivo debe compilarse como un módulo en lugar de como un ensamblado. El compilador genera un módulo denominado Stringer.netmodule, que se puede agregar a un ensamblado.

  3. Compile todos los demás módulos mediante las opciones del compilador necesarias para indicar los demás módulos a los que se hace referencia en el código. En este paso se usa la /addmodule opción del compilador.

    En el ejemplo siguiente, un módulo de código denominado Client tiene un método de punto Main de entrada que hace referencia a un método en el módulo Stringer.netmodule creado en el paso 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. Use el siguiente comando para compilar este código:

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

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

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

    Especifique la /t:module opción porque este módulo se agregará a un ensamblado en un paso futuro. Especifique la /addmodule opción porque el código del cliente hace referencia a un espacio de nombres creado por el código en Stringer.netmodule. El compilador genera un módulo denominado Client.netmodule que contiene una referencia a otro módulo , Stringer.netmodule.

    Nota:

    Los compiladores de C# y Visual Basic admiten la creación directa de ensamblados de varios archivos mediante las dos sintaxis diferentes siguientes.

    Dos compilaciones crean un ensamblado de dos archivos:

    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

    Una compilación crea un ensamblado de dos archivos:

    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. Utilice Assembly Linker (Al.exe) para crear el archivo de salida que contiene el manifiesto del ensamblado. Este archivo contiene información de referencia para todos los módulos o recursos que forman parte del ensamblado.

    En el símbolo del sistema, escriba el siguiente comando:

    al < nombre del módulo><nombre del módulo> /main: < nombre del>/out:< métodonombre de archivo>/target:<tipo de archivo de ensamblado>

    En este comando, los argumentos de nombre del módulo especifican el nombre de cada módulo que se va a incluir en el ensamblado. La /main: opción especifica el nombre del método que es el punto de entrada del ensamblado. La /out: opción especifica el nombre del archivo de salida, que contiene metadatos de ensamblado. La /target: opción especifica que el ensamblado es un archivo ejecutable de aplicación de consola (.exe), un archivo ejecutable de Windows (.win) o un archivo de biblioteca (.lib).

    En el ejemplo siguiente, Al.exe crea un ensamblado que es un ejecutable de aplicación de consola denominado myAssembly.exe. La aplicación consta de dos módulos denominados Client.netmodule y Stringer.netmodule, y el archivo ejecutable denominado myAssembly.exe, que solo contiene metadatos de ensamblado. El punto de entrada del ensamblado es el Main método de la clase MainClientApp, que se encuentra en Client.dll.

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

    Puede usar el desensamblador de IL (Ildasm.exe) para examinar el contenido de un ensamblado o determinar si un archivo es un ensamblado o un módulo.

Consulte también

  • Last updated on