Referencias a espacios de nombres

Alias global y calificador ::

En C# 1.1 puede producirse conflictos a la hora de resolver las referencias a ciertas clases cuando en anidaciones de espacios de nombres existan varias clases y/o espacios de nombres homónimos. Por ejemplo, en el siguiente código:

using System;
namespace Josan
{
  class A
  {
     static void Main(string[] args)
     {
      Método();
     }
     static void Método()
     {
      Console.WriteLine("Josan.System.A.Método()");
      A.Método();
     }
  }
}
class A
{
  static void Método()
  {
   Console.WriteLine("A.Método()");
  }
}

Resulta imposible llamar desde el método Método() de la clase Josan.A a su homónimo en la clase A del espacio de nombres global, por lo que la llamada A.Método() producirá un bucle recursivo infinito y la salida del programa será del tipo:

Josan.System.A.Método()

Josan.System.A.Método()

Josan.System.A.Método()

Para solucionar esto, C# 2.0 introduce la posibilidad de hacer referencia al espacio de nombres global a través de un alias predefinido denominado global y un calificador :: que se usa de la forma <inicio>::<referencia> y permite indicar el punto de <inicio> en la jerarquía de espacios de nombres a partir del que se ha de resolver la <referencia> al tipo o espacio de nombres indicada. Estas referencias se podrán usar en cualquier parte en la que se espere un nombre de tipo o espacio de nombres, tal como una sentencia using, la creación de un objeto con new,... Así, el ejemplo anterior podría resolverse como sigue:

using System;
namespace Josan
{
  class A
  {
     static void Main(string[] args)
     {
      Método();
     }
     static void Método()
     {
      Console.WriteLine("Josan.System.A.Método()");
      global::A.Método();
     }
  }
}
class A
{
  public static void Método()
  {
   Console.WriteLine("A.Método()");
  }
}

Y ahora ya sí que se obtendría la salida buscada:

Josan.System.A.Método()

A.Método()

Alias externos

C# 2.0 va un paso más allá en lo referente a resolver conflictos de ambigüedades en los nombres de los identificadores respecto a C# 1.X. Ahora no solo se pueden usar clases con el mismo nombre siempre y cuando se hallen en espacios de nombres diferentes sino que también se permite usar clases con el mismo nombre y espacio de nombres que se hallen en diferentes ensamblados. Para ello se usan los denominados alias externos.

Antes de las importaciones de espacios de nombres (using) se puede incluir líneas con la siguiente sintaxis:

extern alias <nombreAlias>;

Con esto se estará diciendo al compilador que durante las comprobaciones de sintaxis admita a la izquierda del calificador :: las referencias al alias de espacio de nombres cuyo nombre se le indica.. Cada una de estas referencias se corresponderán con uno o varios ensamblados externos dentro de cuyos espacios de nombres se intentarán resolver la referencia indicada a la derecha del ::. La correspondencia entre estos ensamblados y sus alias se indicarán al compilador de C# mediante parámetros que se podrán pasar en la línea de comandos al hacerles referencia mediante la opción /r siguiendo la sintaxis <nombreAlias>=<rutaEnsamblado> para los valores de la misma; o en el caso de VS.NET 2005, desde la ventana de propiedades de la referencia al ensamblado en la solución.

Por ejemplo, se puede tener un fichero miclase1.cs con el siguiente contenido:

using System;
public class MiClase
{
  public void F()
  {
   Console.WriteLine("F() de mi miclase1.cs");
  }
}

Y otro miclase2.cs con una clase homónima a MiClase:

using System;
public class MiClase
{
  public void F()
  {
   Console.WriteLine("F() de mi miclase2.cs");
  }
}

Para usar ambas clases a la vez en un fichero extern.cs bastaría escribirlo como sigue:

extern alias X;
extern alias Y;
class Extern
{
  static void Main()
  {
   X::MiClase objeto = new X::MiClase();
   objeto.F();
   Y::MiClase objeto2 = new Y::MiClase();
   objeto2.F();
  }
}

Y compilar todo el conjunto con:

csc extern.cs /r:X=miclase1.dll /r:Y=miclase2.dll

csc extern.cs /r:X=miclase1.dll /r:Y=miclase2.dll

Al ejecutarlo podrá comprobarse que la salida demuestra que cada llamada se ha hecho a uno de los diferentes tipos MiClase:

F() de mi miclase1.cs

F() de mi miclase2.cs

Nótese que es perfectamente válido asociar un mismo alias a varios ensamblados y varios alias a un mismo ensamblado. Lo que no se puede es incluir varias definiciones de alias en una misma opción /r, sino que para ello habría que utilizar opciones /r diferentes tal como se ha hecho en el ejemplo. Es decir, la siguiente llamada al compilador no sería correcta:

csc extern.cs /r:X=miclase1.dll,Y=miclase2.dll