¿Cuántas veces has visto la palabra using en C#? ... me aventuraré a decir que muchas, y es que la palabra using tiene varios significados en el lenguaje. Previamente escribí sobre cómo se usa para crear aliases. En este post hablaré sobre otro de sus usos.

En C#, también podemos emplear using para especificar un bloque de código asociado a una o varias instancias de una clase que implemente IDisposable, el hacer uso de estos bloques de código nos ayuda a manejar correctamente este tipo de objetos, ya que se encarga de llamar al método Dispose antes de terminar de ejecutar dicho bloque.

La importancia de llamar al método Dispose en un objeto radica en que es dentro de ese método que se recomienda liberar todos los recursos que fueron empleados para su correcto funcionamiento, y olvidar ejecutar dicho método puede traducirse en problemas que causarán que nuestra aplicación se comporte incorrectamente.

Ejemplo

Para poner un ejemplo, cree la clase Desechable que implementa IDisposable:

public class Desechable : IDisposable
{
    public Desechable()
    {
        Console.WriteLine("Hello, Desechable.");
    }
    //...
    public void Dispose()
    {
        Console.WriteLine("Bye bye, Desechable.");
    }
}

Simplificando sintaxis

Una forma recomendada de usar la clase Desechable es la siguiente, ya que de ese modo nos aseguramos que se llame al método Dispose que, en teoría, se encargará de liberar los recursos asociados a la instancia:

var desechable1 = new Desechable();
try
{
    desechable1.DoSomething();
}
finally
{
    if (desechable1 != null)
    {
        ((IDisposable)desechable1).Dispose();
    }
}

Sin embargo, using hace más sencilla la sintaxis. Podemos reemplazar el código anterior por el siguiente, y nuestro programa segurá funcionando igual:

using (var desechable1 = new Desechable())
{
    desechable1.DoSomething();
}

Mucho más simple, ¿no?

Manejo de errores

A pesar de que a final de cuentas nuestro código quede envuelto en un bloque try-finally, no significa que este se "comerá" las excepciones que puedan ocurrir, es por eso que también podemos usar bloques try-catch dentro de un bloque using:

using (var desechable2 = new Desechable())
{
    try
    {
        desechable2.DoSomethingWithException();
    }
    catch
    {
        Console.WriteLine("¡¡¡¡¡Error!!!!!");
    }
}

Alcance

Al ser bloques de códigos envueltos por { } todas las variables, incluyendo la instancia dentro de using, únicamente estarán disponibles dentro de sus respectivos bloques e intentar usarlas fuera de este provocará un error en tiempo de compilación.

Agrupando declaraciones

Hay ocasiones en las que es necesario instanciar la misma clase varias veces, para dichas ocasiones, using tiene esta sintaxis:

using (Desechable d1 = new Desechable(),
                d2 = new Desechable())
{ // ...

Es importante señalar que tanto d1 como d2 deben ser del mismo tipo. O, si son de distinto, también podemos agruparlas de la siguiente manera:

using (FileStream homerStream = new FileStream("Homer.txt", FileMode.Open))
using (Desechable d1 = new Desechable())
{ // ...

Ejemplo de la vida real

Más que ejemplos de using más bien existen muchas clases en el framework que implementan IDisposable, como el uso de Sockets, recursos de red, conexiones a servicios web y los fluhos de datos, como FileStream:

using (FileStream homerStream = new FileStream("Homer.txt", FileMode.Open))
{
    read = homerStream.Read(buffer, current, buffer.Length);
    while (read != 0)
    {
        read = homerStream.Read(buffer, current, buffer.Length);
        current += read;
        Console.WriteLine(Encoding.UTF8.GetString(buffer));
    }
}

No se recomienda en todos los casos

Hay ocasiones en las que emplear using puede traernos más problemas de los que resuelve, específicamente para gestionar la conexión a un servicio WCF, fuera de ahí no hay problemas conocidos. Esta información me sorprendió incluso a mi.

Lo que sigue

La palabra reservada que revisamos hoy tiene otro par de usos que estaré revisando más adelante en este blog, no olvides suscribirte para estar al tanto.