Usando using, valga la redundancia (C#)

La palabra reservada using tiene diversos usos en el lenguaje C#, y seguro que muchos la utilizamos exclusivamente para importar espacios de nombres (namespaces), ignorando el resto de posibilidades que nos ofrece:

• Importación de espacios de nombres
• Definición de alias, tanto de espacios de nombres como de tipos.
• Adquisición y liberación de recursos

Vamos a dar un repasillo a cada una de estas utilidades, profundizando un poco en aquellas menos habituales.

1. Importación de espacios de nombres

En este caso, la palabra reservada using actúa como una directiva del compilador, haciendo que se puedan utilizar tipos definidos en el espacio de nombres importado sin necesidad de especificarlos de forma explícita en el código.

  using System;
  using System.Collections;...

 
Este es el using más común y conocido, así que poco más hay que decir al respecto…

2. Definición de alias

Otra forma de utilizar using como directiva es crear alias, o nombres cortos alternativos, a namespaces o tipos de datos, que ayuden a evitar conflictos en nombres. Veamos cada uno de ellos.

2.1. Alias de espacios de nombres

Puede ser útil cuando tenemos namespaces cuyos nombres coinciden con el de clases, o en situaciones similares que hacen que el compilador no tenga claro qué estamos intentando decirle. Por ejemplo, observad el siguiente código, que no compila, a pesar de ser aparentemente correcto:

  using System;
  namespace Prueba
  {
    class Saludo
    {
      public static void Run()
      {
        Console.WriteLine("hola");
      }
    }
  }

  namespace OtroNS
  {
    class Prueba
    {
      public static void Main(string[] args)
      {
        Prueba.Saludo.Run();  // No compila
        Console.ReadLine();
      }
    }
  }

 
El problema es que para acceder a clase que queremos utilizar (Saludo) desde un namespace distinto a donde se encuentra definida debemos indicar su ruta completa, es decir, especificar en qué espacio de nombres la encontraremos. Sin embargo, en el ámbito de la clase Prueba, el compilador piensa que el código Prueba.Saludo.Run() está intentando acceder a una propiedad de dicha clase, y como no lo encuentra, revienta en compilación.

La solución a esto es bien sencilla utilizando los alias, puesto que permiten hacer referencia a un espacio de nombres o un tipo utilizando una denominación diferente, lo que eliminará la ambigüedad. Podemos, por ejemplo, utilizar el alias predefinido global, que representa al nivel raíz del árbol de namespaces:

      ...
      public static void Main(string[] args)
      {
        global::Prueba.Saludo.Run();
        Console.ReadLine();
      }
      ...

 
Otra posibilidad, usando using, sería definir un alias personalizado que nos permitiera acceder al espacio de nombres conflictivo utilizando otro identificador:

  ...
  using MiAlias = Prueba;
  ...
      ....
      public static void Main(string[] args)
      {
        MiAlias::Prueba.Saludo.Run();
        Console.ReadLine();
      }
      ...

 
Observad el uso de los dos puntos (::) para indicar que el identificador que se encuentra a su izquierda es un alias. Esto puede ayudar a evitar conflictos cuando el nombre del alias coincida con el de una clase en el ámbito de visibilidad actual.

2.2. Alias a tipos

De la misma forma, podemos crear fácilmente alias a un tipo definido, bien para evitar conflictos en nombres como los descritos anteriormente, o bien para hacer más rápido el acceso a los mismos. En el siguiente ejemplo puede observarse su uso:

  using Strings = System.Collections.Specialized.StringCollection;
  using Con = System.Console;
  ...
  Strings s = new Strings(); // 's' es un StringCollection
  Con.WriteLine("hola");

 
Habréis observado que en este caso no se utilizan los dos puntos (::) para separar el alias del resto, puesto que éste no representa a un namespace, sino a un tipo.

3. Adquisición y liberación de recursos

En este caso, using sirve para especificar bloques de código en los que se van a utilizar recursos que deben ser liberados obligatoriamente al finalizar, como podrían ser conexiones a base de datos, manejadores de ficheros, o recursos del propio sistema operativo. De hecho, salvo en contadas ocasiones, utilizar using es la forma más recomendable de tratar estos asuntos.

En un bloque using se definen una serie de recursos, siempre implementando la interfaz IDisposable, y se delimita un bloque de código en el que éstos serán válidos y visibles. Al salir la ejecución de dicho bloque, estos recursos serán automáticamente liberados llamando a sus respectivos métodos Dispose(). Y esto se hará siempre, independientemente de si la salida del bloque ha sido de forma natural, mediante una excepción o un salto. En otras palabras, el compilador nos asegura que siempre invocará el método Dispose() de todos los recursos comprometidos en la operación.

Un ejemplo muy habitual lo vemos con las conexiones de bases de datos, recurso valioso donde los haya. La forma correcta de tratarlas sería:

  using (SqlConnection conn = new SqlConnection(connectionString)) 
  {
    hacerAlgoConLosDatos(conn);
  }
  // Al llegar aquí, la conexión está liberada. Seguro.
  // Además, la variable conn no es visible.

 
Respecto a la liberación automática de recursos, no hay nada mágico en ello. Internamente, el compilador de C# está transformando el código anterior en:

  SqlConnection conn = new SqlConnection(connectionString);
  try
  {
    hacerAlgoConLosDatos(conn);
  }
  finally
  {
    if (conn != null)
      ((IDisposable)conn).Dispose();
  }

 
Además de asegurar que los recursos son liberados cuando ya no van a ser necesarios, tiene también un efecto positivo al hacer que centremos su uso en un bloque compacto, fuera del cual no se podrá acceder a los mismos; por ejemplo, en el caso anterior, dado que la variable conn no es visible desde fuera del bloque using, evitaremos accesos a ella cuando haya sido liberada, que provocaría errores en tiempo de ejecución.

Y por cierto, una posibilidad interesante y no demasiado conocida es que se pueden especificar varios recursos en el mismo bloque using, de forma que todos ellos se liberen al salir, sin necesidad de tener que anidarlos, siempre que sean del mismo tipo, por ejemplo:

  // Anidando usings
  using (SqlConnection conn1 = new SqlConnection(connstr1))
  {
    using (SqlConnection conn2 = new SqlConnection(connstr2))
    {
       // hacer algo con las dos bases de datos
    }
  }

  // Forma más compacta
  using (SqlConnection conn1 = new SqlConnection(connstr1),
                       conn2 = new SqlConnection(connstr2))
  {
       // hacer algo con las dos bases de datos
  }

 
Publicado en: www.variablenotfound.com.