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
} }
Como puede resultar muy pesado tener que escribir nombres tan largos en cada referencia a tipos así definidos, en C# se ha incluido un mecanismo de importación de espacios de nombres que usa la siguiente sintaxis:
using <espacioNombres>;
Este tipo de sentencias siempre ha de aparecer dentro de una definición de espacio de nombres antes que cualquier definición de miembros de la misma y 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á hacer referencia sin tener que usar calificación completa, como muestra la siguiente versión del último ejemplo:
using EspacioEjemplo.EspacioEjemplo2; namespace EspacioEjemplo.EspacioEjemplo2 { class ClaseEjemplo {} } // (1)
class Principal // Pertenece al espacio de nombres global {
public static void () {
// 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, ya que la definición del espacio de nombres EspacioEjemplo.EspacioEjemplo2 es un miembro del espacio de nombres global. Sin embargo, el siguiente código si 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.
Si una sentencia using importa miembros de igual nombre que miembros definidos en el espacio de nombres donde se incluye, el using no se produce error alguno pero se da
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 {} }
En este ejemplo C deriva de N3.A en vez de N1.N2.A. Si queremos que ocurra 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? En realidad el compilador no puede determinarlo y producirá un error informando de que hay una referencia ambigua a Clase.
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 solucionar los conflictos de nombres sin tener que escribir tanto se ha incluido en C# la posibilidad de definir alias para cualquier tipo de dato, que son sinónimos para los mismos que se definen usando 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 se podría resolver 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 como muestra el siguiente 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 }