Importación de espacios de nombres

Sentencia using

En principio, si desde código perteneciente a una clase definida en un cierto espacio de nombres se desea hacer referencia a tipos definidos en otros espacios de nombres, se ha de referir a los mismos usando su nombre completamente calificado. Por ejemplo:

namespace EspacioEjemplo.EspacioEjemplo2
{
class ClaseEjemplo
{}
}
class Principal // Pertenece al espacio de nombres global
{
public static void Main()
{
EspacioEjemplo.EspacioEjemplo2.ClaseEjemplo c =
new EspacioEjemplo.EspacioEjemplo2.ClaseEjemplo();
}
}

Como puede resultar muy pesado tener que escribir nombres tan largos cada vez que se referencie a tipos así definidos, C# incluye un mecanismo de importación de espacios de nombres que simplifica la tarea y se basa en una sentencia que usa la siguiente sintaxis:

using <espacioNombres>;

Estas sentencias siempre han de aparecer en la definición de espacio de nombres antes que cualquier definición de miembros de la misma. Permiten indicar cuáles serán los espacios de nombres que se usarán implícitamente dentro de ese espacio de nombres. A los miembros de los espacios de nombres así importados se les podrá referenciar sin usar calificación completa. Así, aplicando esto al ejemplo anterior quedaría:

using EspacioEjemplo.EspacioEjemplo2;
namespace EspacioEjemplo.EspacioEjemplo2
{
class ClaseEjemplo
{}
}
// (1)
class Principal    // Pertenece al espacio de nombres global
{
public static void Main()
{
  // EspacioEjemplo.EspacioEjemplo2. está implícito
  ClaseEjemplo c = new ClaseEjemplo();
}
}

Nótese que la sentencia using no podría haberse incluido en la zona marcada en el código como (1) porque entonces se violaría la regla de que todo using ha aparecer en un espacio de nombres antes que cualquier definición de miembro (la definición del espacio de nombres EspacioEjemplo.EspacioEjemplo2 es un miembro del espacio de nombres global) Sin embargo, el siguiente código sí que sería válido:

namespace EspacioEjemplo.EspacioEjemplo2
{
class ClaseEjemplo
{}
}
namespace Principal
{
using EspacioEjemplo.EspacioEjemplo2;
class Principal    // Pertenece al espacio de nombres global
{
  public static void Main()
  {
   ClaseEjemplo c = new ClaseEjemplo();
  }
}
}

En este caso el using aparece antes que cualquier otra definición de tipos dentro del espacio de nombres en que se incluye (Principal) Sin embargo, ahora la importación hecha con el using sólo será válida dentro de código incluido en ese mismo espacio de nombres, mientras que en el caso anterior era válida en todo el fichero al estar incluida en el espacio de nombres global.

Debe tenerse en cuenta que si una sentencia using importa miembros de igual nombre que miembros definidos en el espacio de nombres en que se incluye, no se produce error alguno pero se dará preferencia a los miembros no importados. Un ejemplo:

namespace N1.N2
{
class A {}
class B {}
}
namespace N3
{
using N1.N2;
class A {}
class C: A {}
}

Aquí C deriva de N3.A en vez de N1.N2.A. Si queremos lo contrario tendremos que referenciar a N1.N2.A por su nombre completo al definir C o, como se explica a continuación, usar un alias.

Especificación de alias

Aún en el caso de que usemos espacios de nombres distintos para diferenciar clases con igual nombre pero procedentes de distintos fabricantes, podrían darse conflictos si usamos sentencias using para importar los espacios de nombres de dichos fabricantes ya que entonces al hacerse referencia a una de las clases comunes con tan solo su nombre simple el compilador no podrá determinar a cual de ellas en concreto nos referimos.

Por ejemplo, si tenemos una clase de nombre completamente calificado A.Clase, otra de nombre B.Clase, y hacemos:

using A;
using B;
class EjemploConflicto: Clase {}

¿Cómo sabrá el compilador si lo que queremos es derivar de A.Clase o de B.Clase? Pues en realidad no podrá determinarlo y producirá un error informando de que existe una referencia ambigua a Clase en el código.

Para resolver ambigüedades de este tipo podría hacerse referencia a los tipos en conflicto usando siempre sus nombres completamente calificados, pero ello puede llegar a ser muy fatigoso sobre todo si sus nombres son muy largos. Para solucionarlo sin escribir tanto, C# permite definir alias para cualquier tipo de dato, que son sinónimos que se les definen utilizando la siguiente sintaxis:

using <alias> = <nombreCompletoTipo>;

Como cualquier otro using, las definiciones de alias sólo pueden incluirse al principio de las definiciones de espacios de nombres y sólo tienen validez dentro de las mismas.

Definiendo alias distintos para los tipos en conflictos se resuelven los problemas de ambigüedades. Por ejemplo, el problema del ejemplo anterior podría resolverse así:

using A;
using B;
using ClaseA = A.Clase;
class EjemploConflicto: ClaseA
{} // Heredamos de A.Clase

Los alias no tienen porqué ser sólo referentes a tipos, sino que también es posible escribir alias de espacios de nombres. Por ejemplo:

namespace N1.N2
{
class A {}
}
namespace N3
{
using R1 = N1;
using R2 = N1.N2;
class B
{
  N1.N2.A a; // Campo de nombre completamente calificado N1.N2.A
  R1.N2.A b; // Campo de nombre completamente calificado N1.N2.A
  R2.A c;     // Campo de nombre completamente calificado N1.N2.A
}
}

Al definir alias hay que tener cuidado con no definir en un mismo espacio de nombres varios con igual nombre o cuyos nombres coincidan con los de miembros de dicho espacio de nombres. También hay que tener en cuenta que no se pueden definir unos alias en función de otro, por lo que códigos como el siguiente son incorrectos:

namespace N1.N2 {}
namespace N3
{
using R1 = N1;
using R2 = N1.N2;
using R3 = R1.N2; // ERROR: No se puede definir R3 en función de R1
}