ILDASM - Tool
ILDASM in short stands for IL (Microsoft Intermediate Language) Disassembler. This is a very powerful tool which makes use of Reflection internally to show the different classes and class members contained within an assembly or a module. ILDASM also shows the Metadata contained within the assembly/module. It is very useful in situations you have the assembly but don't know its contents, just use ILDASM to discover the different classes their access modifiers, different class members, their parameters and return types.
To run the ILDASM tool go to Start -> Run within the dialog type ILDASM and press Enter. To view the contents of assembly/module choose the assembly/module from the File ->Open dialog of ILDASM. Note: ILDASM can only be used to view the contents of a .NET PE (Exe/Dll) file, it cannot be used to view the contents of a regular PE file.

Example 1: Module
Let's get started... 
To start up, I have written a small class (given below) and saved it as FirstClass.cs. This class is a public class with just one method.

using System;
public class FirstClass
{
  public void PrintMessage()
  {
    Console.WriteLine("I am First Class");
  }
}

Now we first compile this class into a Module, the compilation string will be:
csc /t:module FirstClass.cs

This will create a FirstClass.netmodule file in the directory you ran the compiler.
Note: We use the /t:module compiler switch to compile a module.
Now let's examine this module, fire up the ILDASM tool, and select the FirstClass.netmodule file from File -> Open"dialog of the ILDASM tool. There is one hitch here although, ILDASM does not shown the *.netmodule extension in the Open File dialon.
To workaround this, select Any type (*.*)" from the Types of Files dropdown in the Open File Dialog and then select the module.

Once you have the right file selected you should be able to see something like below

Figure 1: ILDASM: FirstClass Module

Figure 2: ILDASM: Manifest of the FirstClass Module

Example 2: Assembly
In this example we use the same FirstClass class but this time we compile it as an assembly. So now our compilation string changes to:
csc /t:library FirstClass.cs

The above will compile a library Dll called FirstClass.dll in the directory you ran the command.
Again we fire up the ILDASM tool to examine this assembly (I hope by now you know how to load the library dll into ILDASM??). On first looks it might seem the same as the module definition, but the real magic is within the Manifest, so without any further delay double-click the Manifest item within the ILDASM tool.

Figure 3: ILDASM: Manifest of FirstClass Assembly

Example 3: Consuming a Module
Since modules can't be used directly you have to create an assembly that references the module. Let's take one more example to learn to consume Modules. Write the below code into Notepad and save it as MainClient.cs.

public class MainClient
{
  public static void Main()
  {
    FirstClass fc = new FirstClass();
    fc.PrintMessage();
  }
}

Firstly, we will compile the application referencing the module. Compile the above file with the compilation string:
csc /addmodule:FirstClass.netmodule MainClient.cs

This will compile a Console Application MainClient.exe.
Note that the compiler option /addmodule is used to reference a module.
Go to the command prompt, navigate to the folder that hosts the application and run it, you should see the output as 
I am First Class.
To understand what happens internally, open the MainClient.exe file in ILDASM and Double-Click the Manifest item.

Figure 4: ILDASM: Manifest of MainClass

Conclusion
From the above example it is clear that both Modules and Assemblies have Manifests. This Manifest contains Metadata information of the Module/Assembly as well as it contains detailed Metadata of other assemblies/modules references (exported). It's the Assembly Manifest which differentiates between an Assembly and a Module. 
The Assembly Manifest contains important information required by the .NET Runtime to execute the IL code within the PE file successfully! 
We also saw how Versioning support has been built into the .NET PE files. Some curious learners among you might have also noticed that Referencing Assemblies/Modules only adds the reference to the assembly/module in your code and the code in the external file does not get imported into your code. This is the reason that you have to supply all the Assemblies/Modules you use in your Application along with the Assembly that builds you application.

Now, using ILDASM isn't so hard is it? Play with it and you will learn a lot of things :)