martes, 27 de febrero de 2007

La sentencia Using

La mayoría de los programas escritos en C# contienen al menos, aunque no es requisito, una sentencia using.

Sabemos que con esta sentencia utilizamos un namespace determinado y con esto acortamos notoriamente los nombres de las clases y tipos que utilizaremos en nuestro código.

La manera de utilizar la sentencia using para importar un namespace es la siguiente.

using MiNamespace1;
using MiNamespace2;

Con esto se importan todas las classes de los namespaces referenciados.

¿Que pasa si tanto MiNamespace1 como MiNamespace2 contienen una clase llamada MiClase?
Esto crearía un conflicto de nombres, ya que el compilador no sabría a qué clase nos referimos cuando utilizamos MiClase (si a MiNamespace1.MiClase o MiNamespace2.MiClase).
Para solucionar este conflicto es posible crear un alias para cada espacio de nombres importado. Podemos definir un alias para el using de la siguiente manera.

using Alias = MiNamespace1;


De esta manera ahora para referirnos a MiNamespace1.MiClase lo hacemos como Alias.MiClase (el ejemplo no es el mejor
para notar lo útil que puede ser esta sentencia, pero imaginate que tengas que utilizar namespaces como los siguientes).

using Alias1 = Empresa.Departamento.Proyecto.Modulo1;
using Alias2 = Empresa.Departamento.Proyecto.Modulo2;

Aquí sí que acorta notoriamente la codificación de los nombres de las clases.

*************************************

Pero si creias que la sentencia using se utiliza únicamente para importar namespaces estas muy equivocado.
Tambien tiene la función de definir bloques que utilizan un recurso determinado. Un recurso es una clase que implementa
la interfaz IDisposable, es decir, contiene un método para definir cuando el recurso ya no está siendo utilizado.

El Bloque using tiene como finalidad utilizar un recurso definido durante el alcance del bloque y
luego liberar el recurso llamando al método Dispose().

El siguiente es un ejemplo práctico de un bloque using.

using (Recurso r = new Recurso())
{
// utilización de recurso r.
}

Lo cual es equivalente a lo siguiente:

Recurso r = new Recurso(); // u otra asignacion.
try {
// utilización de recurso r.
}
finally
{

// Liberación del recurso -> r.Dispose();
r.Dispose();
}


Claro, existe una diferencia entre utilizar un bloque using y un bloque try/finally. En el primero el recurso
utilizado es sólo de lectura, mientras que es modificable en un bloque try/finally.

Es posible, también, definir varias instancias de un mismo recurso al inicializar un bloque using, de la siguiente manera:

using(Recurso r1=X, r2=Y, r3=Z){
...
}

Sentencia que es equivalente a:

using(Recurso r1=x ){
using(Recurso r2=Y){
using(Recurso r3=Z){
...
}
}
}

y a:

try
{
Recurso r1=X, r2=Y, r3=Z;
...
}
finally

{
r1.Dispose();
r2.Dispose();
r3.Dispose();
}

Aplicaciones para esta sentencia son, por ejemplo, conexiones a bases de datos, creacion de una lista de objetos, entre otras.

1 comentario:

D.a.N Ortega Marte dijo...

Excelente Post para nada esta desperdiciado :D