8.12 Namespaces and assemblies
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.
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 CSharp.Introduction
{
public class HelloMessage
{
public string Message {
get {
return "hello, world";
}
}
}
}
shows the HelloMessage class in a namespace named CSharp.Introduction. The
HelloMessage
class provides a read-only property named Message. Namespaces can nest, and
the declaration
namespace CSharp.Introduction
{.}
is shorthand for two levels of namespace nesting:
namespace CSharp
{
namespace Introduction
{.}
}
C# LANGUAGE SPECIFICATION
46
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.
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 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 CSharp.Introduction
namespace. The occurrences
of HelloMessage are shorthand for 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 = 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. A command-line compiler might enable
compilation of a class library and an
application that uses that library with the following command-line
invocations:
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.