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.
[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:
[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.
[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:
[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:
[C#]
csc /t:module Stringer.cs
csc Client.cs /addmodule:Stringer.netmodule
One compilation creates a two-file assembly:
[Visual Basic]
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.
