Exportar (0) Imprimir
Expandir todo
Este artículo se tradujo de forma manual. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

Cómo: Compilar un ensamblado de varios archivos

En este artículo se explica cómo crear un ensamblado de múltiples archivos e incluye código que muestra cada paso del procedimiento.

Nota Nota

El IDE de Visual Studio para C# y Visual Basic solo se pueden utilizar para crear ensamblados de un solo archivo. Si desea crear ensamblados de múltiples archivos, debe usar compiladores de la línea de comandos o Visual Studio con Visual C++.

Para crear un ensamblado de varios archivos

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

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

    
    // 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.");
            }
        }
    }
    
    
    

    Use el comando siguiente para compilar este código:

    
    csc /t:module Stringer.cs
    
    
    

    Si se especifica el parámetro module con la opción de compilador /t: se indica que el archivo se debe compilar como un módulo y no como un ensamblado. El compilador produce un módulo denominado Stringer.netmodule, que se puede agregar a un ensamblado.

  2. Compile los módulos restantes, usando las opciones de compilador necesarias para indicar los otros módulos a los que hace referencia el código. En este paso se usa la opción de compilador /addmodule.

    En el siguiente ejemplo, un módulo de código denominado Client tiene un método Main de punto de entrada que hace referencia a un método del módulo Stringer.dll creado en el paso 1.

    
    using System;
    using myStringer; //The namespace created in Stringer.netmodule.
    
    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();
        }
    }
    
    
    

    Use el comando siguiente para compilar este código:

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

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

    Nota Nota

    Los compiladores de C# y Visual Basic son compatibles con la creación directa de ensamblados de múltiples archivos mediante las dos siguientes sintaxis distintas.

    • Dos compilaciones crean un ensamblado de dos archivos:

      
      csc /t:module Stringer.cs
      csc Client.cs /addmodule:Stringer.netmodule
      
      
      
    • Una compilación crea un ensamblado de dos archivos:

      
      csc /out:Client.exe Client.cs /out:Stringer.netmodule Stringer.cs
      
      
      
  3. Use la herramienta Assembly Linker (Al.exe) para crear el archivo de salida que contiene el manifiesto del ensamblado. Este archivo contiene información de referencia de 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 método> /out:<nombre del archivo> /target:<tipo de archivo de ensamblado>

    En este comando, los argumentos de nombre de archivo especifican el nombre de todos los módulos que se van a incluir en el ensamblado. La opción /main: especifica el nombre del método que es el punto de entrada del ensamblado. La opción /out: especifica el nombre del archivo de salida que contiene metadatos del ensamblado. La opción /target: 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 siguiente ejemplo, Al.exe crea un ensamblado que es un ejecutable de aplicación de consola denominado myAssembly.exe. Esta aplicación está formada por dos módulos denominados Client.netmodule y Stringer.netmodule y por el archivo ejecutable denominado myAssembly.exe, que solo contiene metadatos del ensamblado. El punto de entrada del ensamblado es el método Main de la clase MainClientApp, que se encuentra en Client.dll.

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

    Se puede usar el Desensamblador de MSIL (Ildasm.exe) para examinar el contenido de un ensamblado, o determinar si un archivo es un ensamblado o un módulo.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft