Ensamblados vs Espacios de Nombres

El .NET Framework organiza clases (tipos) en dos diferentes niveles: espacios de nombres (namespaces) y ensamblados (assemblies). Vamos a ver las diferencias entre ambos en este post.

Ensamblados

Un ensamblado (assembly) es la unidad física que contiene código .NET compilado (clases).

Aun cuando un ensamblado puedo ser dividido en múltiples archivos, es mas fácil pensar en un ensamblado como un solo archivo con código .NET. En el  .NET Framework, todas nuestras clases (tipos) existen en ensamblados.

Cada vez que compilas un proyecto de aplicación o de librería de clases, un ensamblado es creado. El ensamblado puede ser un ejecutable (archivo.exe) o una librería (archivo .dll). La única diferencia es que el ejecutable contiene un punto de entrada (entry point) para poder ser ejecutado por Windows. Las librerías son accedidas por ejecutables.

Los ensamblados tienen un numero de versión expresado en el formato: <versión mayor>.<versión menor>.<numero de compilación>.<numero de revisión>. Por ejemplo, un ensamblado puede tener el numero de versión 2.6.2000.30.

Cada ensamblado contiene meta data con información sobre si mismo y las clases que contiene. Esto es llamado manifiesto de ensamblado. El manifiesto de ensamblado contiene principalmente la siguiente información :

1. El nombre del ensamblado
2. Numero de versión
3. Cultura y lenguaje soportados por el ensamblado
4. Información sobre las clases contenidas en el ensamblado
5. Una lista de otros ensamblados a los que este ensamblado hace referencia

El manifiesto del ensamblado es utilizado cuando necesitamos utilizar clases de otro ensamblado en nuestro código. Como un ensamblado es capaz de describirse asimismo, no necesita del Registro de Windows para hacer sus clases disponibles para otros ensamblados. Esto hace a .NET una mucho mejor opción que usar COM, en donde nuevas versiones de un componente pueden romper una aplicación que utiliza una versión antigua.

Un archivo AssemblyInfo.cs (o .vb si estas usando Visual Basic) es creado en la carpeta especial Propiedades (Properties) por Visual Studio cuando creas un proyecto nuevo. Este archivo contiene información general sobre el ensamblado, tal como titulo , descripción, compañía, y copyright.

En este archivo también podemos especificar la versión del ensamblado que queremos usar. Aquí esta un ejemplo:

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("SampleApp")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("My Company")]
[assembly: AssemblyProduct("SampleApp")]
[assembly: AssemblyCopyright("Copyright © My Company 2010")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]

// Setting ComVisible to false makes the types in this assembly not visible
// to COM components.  If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]

// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("61275b5f-3883-41bb-87fc-79648a6fe2b7")]

// Version information for an assembly consists of the following four values:
//
//      Major Version
//      Minor Version
//      Build Number
//      Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

Observa que la versión de ensamblado puede ser diferente a la versión de archivo. La versión de ensamblado es usado por .NET Framework. La versión de archivo es lo que se muestra en Windows cuando se abren las propiedades del archivo.

Si deseas tener un numero de compilación y un numero de revisión diferentes cada vez que compiles el proyecto, puedes hacer que el compilador lo haga por ti utilizando el símbolo “*”, como se muestra en los comentarios del código anterior. Esto incrementara el numero por ti en cada compilación.

Ensamblados Privados y Ensamblado Compartidos

Lo ensamblados pueden ser desplegados con la aplicación como privados o como compartidos.

Los ensamblados privados son destinados a ser utilizados por una solo aplicación. Este es el comportamiento normal.

Todos los ejecutables y librerías que una aplicación necesita son copiados a la carpeta de la aplicación en el directorio Archivos de Programa. De esta manera, diferentes aplicaciones pueden tener una versión diferente del mismo ensamblado. Cuando la aplicación necesita ser actualizada, los ensamblados correspondientes son simplemente reemplazados, y otra aplicaciones no serán afectadas.

Cuando necesitas hacer tu código disponible para múltiples aplicaciones, los ensamblados pueden ser desplegados como compartidos, en lugar de ser copiado múltiples veces.

Para que el ensamblado compartido este disponible para cualquier aplicación, es necesario agregarlo a un directorio especial conocido como Caché de Ensamblados Globales (Global Assembly Cache o GAC). Los ensamblados no pueden ser simplemente copiados a este directorio. Es necesario utilizar una de las siguientes herramientas:

• Microsoft Windows Installer
• Herramienta Gacutil.exe
• Herramienta de Configuración de .NET Framework. Esta opción fue removida en .NET 4.

Espacios de Nombres

Un espacio de nombres (namespace) es una unidad lógica de clases y tipos. Los espacios de nombres no son un reemplazo de ensamblados sino un complemento. Cada clase es parte de un ensamblado y de un espacio de nombres. También puedes tener dos clases que son parte de un mismo espacio de nombres pero que pertenecen a diferentes ensamblados.

Los espacios de nombres son utilizados para evitar la colisión de nombres. Si tienes dos clases con el mismo nombre pero diferente funcionalidad, colocarías cada clase en un espacio de nombres diferente. Cuando necesites utilizar una de ellas solo haces referencia al espacio de nombres apropiado.

Los espacios de nombres pueden contener otros espacios de nombres. Esto crea una jerarquía de espacios de nombres y clases con múltiples niveles.

Toma como ejemplo la Librería de Clases Base de .NET Framework. Todas las clases en esta librería están en el espacio de nombre raíz System. Y dentro del espacio de nombres System se encuentra el espacio de nombres Windows, con clases enfocadas a crear aplicaciones de escritorio. También dentro del espacio de nombres System se encuentra el espacio de nombres Web, con clases enfocadas a crear aplicaciones web. Dentro de cada espacio de nombres se encuentran mas espacios de nombres con clases para funcionalidad mas especifica.

En las propiedades de proyecto puedes definir el espacio de nombres por defecto que deseas utilizar para todas las clases en el proyecto, el cual usualmente es el nombre del proyecto. Todas las clases en el proyecto serán parte del espacio de nombres por defecto, a menos que definas otro espacio de nombres cuando estés declarando tus clases. En C#, harías algo como esto:

namespace MyApp
{
	namespace MyProject
	{
		using System;

		class MyClass
		{
			public static void Main()
			{
				Console.WriteLine("Hello World!");
			}
		}
	}
}

En este código, la clase MyClass esta dentro del espacio de nombres MyProject, el cual a su vez esta dentro del espacio de nombres MyApp.

También podemos declarar los espacios de nombres anidados de esta manera:

namespace MyApp.MyProject
{
	using System;

	class MyClass
	{
		public static void Main()
		{
			Console.WriteLine("Hello World!");
		}
	}
}

El nombre completo de la clase seria MyApp.MyProject.MyClass.

Para hacer referencia a una clase en otro espacio de nombres puedes utilizar el nombre completo o puedes importar los espacios de nombres que deseas utilizar. En el ejemplo anterior estamos importando el espacio de nombres System con la palabra clave using (imports en Visual Basic).

También pudimos haber llamado la función WriteLine de esta manera:

System.Console.WriteLine(“Hello World!”);

Así que cada vez que ocupemos utilizar una clase en nuestro código, primero debemos hacer referencia al ensamblado que contiene la clase, si es que la clase no es parte del mismo proyecto, y también será necesario saber el espacio de nombres donde la clase se encuentra e importarlo.

Por favor deja un comentario si tienes alguna pregunta.