What is an assembly?

An assembly is sometimes described as a logical .EXE or .DLL, and can be an application
(with a main entry point) or a library. An assembly consists of one or more files
(dlls, exes, html files etc), and represents a group of resources, type definitions,
and implementations of those types. An assembly may also contain references to
other assemblies. These resources, types and references are described in a block
of data called a manifest. The manifest is part of the assembly, thus making the
assembly self-describing.

An important aspect of assemblies is that they are part of the identity of
a type. The identity of a type is the assembly that houses it combined with
the type name. This means, for example, that if assembly A exports a type called
T, and assembly B exports a type called T, the .NET runtime sees these as two
completely different types. Furthermore, don't get confused between assemblies
and namespaces - namespaces are merely a hierarchical way of organising type
names. To the runtime, type names are type names, regardless of whether namespaces
are used to organise the names. It's the assembly plus the typename (regardless
of whether the type name belongs to a namespace) that uniquely indentifies a
type to the runtime.

Assemblies are also important in .NET with respect to security - many of the
security restrictions are enforced at the assembly boundary.

Finally, assemblies are the unit of versioning in .NET - more on this below.

How can I produce an assembly?

The simplest way to produce an assembly is directly from a .NET compiler. For
example, the following C# program:

public class CTest

{

public CTest() { System.Console.WriteLine( "Hello from CTest" ); }

}

can be compiled into a library assembly (dll) like this:

csc /t:library ctest.cs

You can then view the contents of the assembly by running the "IL Disassembler"
tool that comes with the .NET SDK.

Alternatively you can compile your source into modules, and then combine the
modules into an assembly using the assembly linker (al.exe). For the C# compiler,
the /target:module switch is used to generate a module instead of an assembly.

What is the difference between a private assembly and a shared assembly?

Location and visibility: A private assembly is normally used by a single application,
and is stored in the application's directory, or a sub-directory beneath. A
shared assembly is normally stored in the global assembly cache, which is a
repository of assemblies maintained by the .NET runtime. Shared assemblies are
usually libraries of code which many applications will find useful, e.g. the
.NET framework classes.

Versioning: The runtime enforces versioning constraints only on shared assemblies,
not on private assemblies.

How do assemblies find each other?

By searching directory paths. There are several factors which can affect the
path (such as the AppDomain host, and application configuration files), but
for private assemblies the search path is normally the application's directory
and its sub-directories. For shared assemblies, the search path is normally
same as the private assembly path plus the shared assembly cache.

How does assembly versioning work?

Each assembly has a version number called the compatibility version. Also each
reference to an assembly (from another assembly) includes both the name and
version of the referenced assembly.

The version number has four numeric parts (e.g. 5.5.2.33). Assemblies with
either of the first two parts different are normally viewed as incompatible.
If the first two parts are the same, but the third is different, the assemblies
are deemed as 'maybe compatible'. If only the fourth part is different, the
assemblies are deemed compatible. However, this is just the default guideline
- it is the version policy that decides to what extent these rules are enforced.
The version policy can be specified via the application configuration file.

Remember: versioning is only applied to shared assemblies, not private assemblies.

How can I develop an application that automatically updates itself
from the web?

For .NET 1.x, use the Updater Application Block.