Ejemplo de ensamblado de varios archivos

En esta sección se ofrece un ejemplo completo que ilustra los pasos necesarios para crear un ensamblado de varios archivos.

Paso 1: Compilar archivos con espacios de nombres a los que hacen referencia otros archivos

Este ejemplo comienza con algo de código sencillo para el archivo Stringer. Éste tiene un espacio de nombres denominado myStringer con 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 SDK.
Imports System
Namespace myStringer 
   Public Class Stringer
      Public Sub StringerMethod() 
         Console.WriteLine("This is a line from StringerMethod.")
      End Sub
   End Class
End Namespace
[C#]
// Assembly building example in the .NET Framework SDK.
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:

vbc /t:module Stringer.vb
[C#]
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.

Paso 2: Compilar módulos con referencias a otros módulos

En este paso se usa la opción de compilador /addmodule. En este 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.

En el siguiente ejemplo se muestra el código de Client.

Imports System
Imports myStringer  'The namespace created in Stringer.netmodule.
Class MainClientApp
   ' Shared method Main is the entry point method.
   Public Shared Sub Main()
      Dim myStringInstance As New Stringer()
      Console.WriteLine("Client code executes")
      'myStringComp.Stringer()
      myStringInstance.StringerMethod()
   End Sub
End Class
[C#]
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");
      //myStringComp.Stringer();
      myStringInstance.StringerMethod();
   }
}

Use el comando siguiente para compilar este código:

vbc /addmodule:Stringer.netmodule /t:module Client.vb
[C#]
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 de Stringer.netmodule. El compilador produce un módulo denominado Client.netmodule que contiene una referencia a otro módulo, Stringer.netmodule.

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

• Dos compilaciones crean un ensamblado de dos archivos:

  vbc /t:module Stringer.vb
  vbc Client.vb /addmodule:Stringer.netmodule
  [C#]
  csc /t:module Stringer.cs
  csc Client.cs /addmodule:Stringer.netmodule
  

• Una compilación crea un ensamblado de dos archivos:

  vbc /out:Stringer.netmodule Stringer.vb /out:Client.exe Client.vb
  [C#]
  csc /out:Client.exe Client.cs /out:Stringer.netmodule Stringer.cs
  

Paso 3: Crear un ensamblado de varios archivos mediante la utilidad

La herramienta Assembly Linker (Al.exe) se puede usar para crear un ensamblado a partir de una colección de módulos de código compilados.

Para crear un ensamblado de varios archivos mediante la herramienta Assembly Linker

• 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 de archivo> /target:<tipo de archivo del 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 el archivo ejecutable denominado myAssembly.exe, que sólo 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.

Vea también

Crear ensamblados | Ver el contenido de un ensamblado | Cómo el motor de tiempo de ejecución ubica ensamblados | Generar un ensamblado de varios archivos