This documentation is archived and is not being maintained.

1.12 Namespaces and assemblies

Visual Studio .NET 2003

The programs presented so far have stood on their own except for dependence on a few system-provided classes such as System.Console. It is far more common, however, for real-world applications to consist of several different pieces, each compiled separately. For example, a corporate application might depend on several different components, including some developed internally and some purchased from independent software vendors.

Namespaces and assemblies enable this component-based system. Namespaces provide a logical organizational system. Namespaces are used both as an "internal" organization system for a program, and as an "external" organization system — a way of presenting program elements that are exposed to other programs.

Assemblies are used for physical packaging and deployment. An assembly may contain types, the executable code used to implement these types, and references to other assemblies.

There are two main kinds of assemblies: applications and libraries. Applications have a main entry point and usually have a file extension of .exe; libraries do not have a main entry point, and usually have a file extension of .dll.

To demonstrate the use of namespaces and assemblies, this section revisits the "hello, world" program presented earlier, and splits it into two pieces: a class library that provides messages and a console application that displays them.

The class library will contain a single class named HelloMessage. The example

// HelloLibrary.cs
namespace Microsoft.CSharp.Introduction
{
   public class HelloMessage
   {
      public string Message {
         get {
            return "hello, world";
         }
      }
   }
}

shows the HelloMessage class in a namespace named Microsoft.CSharp.Introduction. The HelloMessage class provides a read-only property named Message. Namespaces can nest, and the declaration

namespace Microsoft.CSharp.Introduction
{...}

is shorthand for several levels of namespace nesting:

namespace Microsoft
{
   namespace CSharp
   {
      namespace Introduction
      {...}
   }
} 

The next step in the componentization of "hello, world" is to write a console application that uses the HelloMessage class. The fully qualified name for the class — Microsoft.CSharp.Introduction.HelloMessage — could be used, but this name is quite long and unwieldy. An easier way is to use a "using namespace directive," which makes it possible to use all of the types in a namespace without qualification. The example

// HelloApp.cs
using Microsoft.CSharp.Introduction;
class HelloApp
{
   static void Main() {
      HelloMessage m = new HelloMessage();
      System.Console.WriteLine(m.Message);
   }
}

shows a using namespace directive that refers to the Microsoft.CSharp.Introduction namespace. The occurrences of HelloMessage are shorthand for Microsoft.CSharp.Introduction.HelloMessage.

C# also enables the definition and use of aliases. A using alias directive defines an alias for a type. Such aliases can be useful in situation in which name collisions occur between two class libraries, or when a small number of types from a much larger namespace are being used. The example

using MessageSource = Microsoft.CSharp.Introduction.HelloMessage;

shows a using alias directive that defines MessageSource as an alias for the HelloMessage class.

The code we have written can be compiled into a class library containing the class HelloMessage and an application containing the class HelloApp. The details of this compilation step might differ based on the compiler or tool being used. Using the command-line compiler provided in Visual Studio .NET, the command-line invocations are

csc /target:library HelloLibrary.cs 
csc /reference:HelloLibrary.dll HelloApp.cs

which produce a class library named HelloLibrary.dll and an application named HelloApp.exe.

Show: