Export (0) Print
Expand All

Multifile Assembly Example

.NET Framework 1.1

This section provides a complete example that illustrates the steps required to create a multifile assembly.

Step 1 — Compiling Files with Namespaces Referenced by Other Files

This example starts with some simple code for the Stringer file. Stringer has a namespace called myStringer with a class called Stringer. The Stringer class contains a method called StringerMethod that writes a single line to the console.

' 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 the following command to compile this code:

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

Specifying the module parameter with the /t: compiler option indicates that the file should be compiled as a module rather than as an assembly. The compiler produces a module called Stringer.netmodule, which can be added to an assembly.

Step 2 — Compiling Modules with References to Other Modules

This step uses the /addmodule compiler option. In this example, a code module called Client has an entry point Main method that references a method in the Stringer.dll module created in Step 1.

The following example shows the code for 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 the following command to compile this code:

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

Specify the /t:module option because this module will be added to an assembly in a future step. Specify the /addmodule option because the code in Client references a namespace created by the code in Stringer.netmodule. The compiler produces a module called Client.netmodule that contains a reference to another module, Stringer.netmodule.

Note   The C# and Visual Basic compilers support directly creating multifile assemblies using the following two different syntaxes.
  • Two compilations create a two-file assembly:
    vbc /t:module Stringer.vb
    vbc Client.vb /addmodule:Stringer.netmodule
    [C#]
    csc /t:module Stringer.cs
    csc Client.cs /addmodule:Stringer.netmodule
    
  • One compilation creates a two-file assembly:
    vbc /out:Stringer.netmodule Stringer.vb /out:Client.exe Client.vb
    [C#]
    csc /out:Client.exe Client.cs /out:Stringer.netmodule Stringer.cs
    

Step 3 — Creating a Multifile Assembly Using the Assembly Linker

You can use the Assembly Linker (Al.exe) to create an assembly from a collection of compiled code modules.

To create a multifile assembly using the Assembly Linker

  • At the command prompt, type the following command:

    al <module name> <module name> ... /main:<method name> /out:<file name> /target:<assembly file type>

    In this command, the module name arguments specify the name of each module to include in the assembly. The /main: option specifies the method name that is the assembly's entry point. The /out: option specifies the name of the output file, which contains assembly metadata. The /target: option specifies that the assembly is a console application executable (.exe) file, a Windows executable (.win) file, or a library (.lib) file.

In the following example, Al.exe creates an assembly that is a console application executable called myAssembly.exe. The application consists of two modules called Client.netmodule and Stringer.netmodule, and the executable file called myAssembly.exe, which contains only assembly metadata . The entry point of the assembly is the Main method in the class MainClientApp, which is located in Client.dll.

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

You can use the MSIL Disassembler (Ildasm.exe) to examine the contents of an assembly, or determine whether a file is an assembly or a module.

See Also

Creating Assemblies | Viewing Assembly Contents | How the Runtime Locates Assemblies | Building a Multifile Assembly

Show:
© 2014 Microsoft