Alias de espacio de nombres en C#
Este tutorial ayudará a comprender el concepto de alias de espacio de nombres en C#. Implementaremos un código de demostración para ayudarlo a comprender completamente este concepto.
Espacio de nombres en C#
En C#, se usa un espacio de nombres para organizar los métodos, las clases, las estructuras y las enumeraciones de forma lógica para hacerlos eficientes y controlar el alcance de las funciones y las clases.
El alias de tipo o espacio de nombres es útil para hacer que el código sea fácil de entender y ahorra tiempo a los desarrolladores. El alias de tipo es útil cuando desea crear un alias de una clase o función específica desde un solo espacio de nombres.
La palabra clave using nos permite acceder a estas funcionalidades en C#.
la Directiva usando en C#
La directiva del compilador using en C# se puede usar para definir un ámbito. También se puede usar para crear un alias para un espacio de nombres, importar miembros estáticos de una clase o importar tipos específicos de otros espacios de nombres.
La entrada y salida de la consola es lo básico en la programación. En C#, la clase Consola del espacio de nombres Sistema se usa para realizar operaciones de consola, es decir, entrada o salida.
Debes haberlo usado en proyectos C# como using System para acceder a WriteLine(), ReadLine(), etc.
Alias en C#
Alias ayuda a evitar declaraciones o clases ambiguas al reemplazar los nombres largos de espacios de nombres/clases por nombres cortos. Vuelve a entrenar la funcionalidad lógica original.
El desarrollador puede usar un alias para utilizar la funcionalidad del espacio de nombres de manera más rápida y efectiva. No tiene efectos adversos en el tiempo de ejecución del programa; más bien, acelera el tiempo de desarrollo.
Primero, para comprender el concepto, creemos un proyecto de consola C# simple y escribamos el siguiente código que no usa alias.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace NamespaceAliasing {
class Program {
static void Main(string[] args) {
Console.WriteLine("Hi! I am a Console.WriteLine");
Console.Write("Let me know your good name: ");
var name = Console.ReadLine();
Console.WriteLine("Welcome: " + name);
Console.ReadKey();
}
}
}
Si escribe usuario como entrada, la salida será la siguiente.
Hi! I am a Console.WriteLine
Let me know your good name: user
Welcome: user
Cuando crea un proyecto de consola C# en Visual Studio, importa algunos espacios de nombres básicos por sí mismo. Como puede ver, el sistema de uso y otros espacios de nombres se importan sobre el archivo de origen.
Cuando importa un espacio de nombres, el compilador sabe que necesita acceder a cada clase miembro, método y variable de ese espacio de nombres. Entonces, al importar el espacio de nombres System, puede acceder a los métodos ReadLine(), WriteLine(), Write().
Ahora, vamos a crear un alias para la clase Consola para que no siempre tengamos que escribirlo mientras invocamos sus métodos asociados. Creamos un alias S a System.Console en el siguiente código.
Ahora, podemos acceder a los métodos de la consola utilizando este alias S en lugar de escribir Console.
Es importante tener en cuenta que un alias es solo otro nombre para un identificador, por lo que el identificador anterior funcionará como si estuviera disponible antes.
Por ejemplo, en el siguiente código, System.Console seguirá siendo accesible y funcional como lo era antes de declarar cualquier alias.
using S = System.Console;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace NamespaceAliasing {
class Program {
static void Main(string[] args) {
S.WriteLine("Hi! I am a S.WriteLine");
S.Write("Let me know your good name: ");
var name = S.ReadLine();
S.WriteLine("Welcome: " + name);
System.Console.WriteLine("I am Console.WriteLine");
S.ReadKey();
}
}
}
Producción :
Hi! I am a S.WriteLine
Let me know your good name: user
Welcome: user
I am Console.WriteLine
Otro uso de un alias es cuando tiene que usar varias clases de diferentes espacios de nombres pero tiene tipos con los mismos nombres.
Puede implementar esto usando el nombre completo que hace referencia a clases específicas o puede crear alias para espacios de nombres y tipos de acceso usando alias.
El siguiente ejemplo muestra un escenario donde dos espacios de nombres tienen métodos con el mismo nombre.
using S = System.Console;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace NamespaceAliasing {
using Alias1 = NameSpace1.ClassOne;
using Alias2 = NameSpace2.ClassTwo;
class Program {
static void Main(string[] args) {
var object1 = new Alias1();
object1.Sample();
var object2 = new Alias2();
object2.Sample();
S.ReadKey();
}
}
}
namespace NameSpace1 {
public class ClassOne {
public void Sample() {
S.WriteLine("I am a Sample from Namespace1");
}
}
}
namespace NameSpace2 {
class ClassTwo {
public void Sample() {
S.WriteLine("I am a Sample from Namespace2");
}
}
}
Producción :
I am a Sample from Namespace1
I am a Sample from Namespace2
El fragmento de código anterior tiene dos espacios de nombres llamados NameSpace1 y NameSpace2. Ambos tienen clases llamadas ClassOne y ClassTwo,, respectivamente.
Los métodos de ambos espacios de nombres tienen el mismo nombre, por lo que si los llamamos simplemente usando su nombre, es decir, Sample(), el compilador no puede especificar desde qué espacio de nombres se está llamando.
Tenemos que especificar la referencia completa escribiendo Namespace1.ClassOne.Sample() para su correcta ejecución.
Es desafiante y ambiguo si lo usamos varias veces en nuestro código. Este problema se puede resolver creando alias de espacios de nombres como los creamos en el código de ejemplo anterior.
No necesitamos escribir Namespace1.ClassOne.Sample cada vez; más bien, podemos usar los alias Alias1 y Alias2.
El alias puede hacer referencia a los miembros estáticos de una clase y usarlos por sus nombres en lugar de escribir la referencia completa. Por ejemplo, la clase Math del espacio de nombres System contiene funciones estáticas como Sqrt() y miembros estáticos como PI y E.
El siguiente es un ejemplo de cómo llamar a una función estática desde otro espacio de nombres mediante la creación de un alias.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static NameSpace1.SampleClass;
namespace StaticAliasing {
class Program {
static void Main(string[] args) {
function1();
Console.ReadKey();
}
}
}
namespace NameSpace1 {
public class SampleClass {
public static void function1() {
System.Console.WriteLine("I am a static function.");
}
}
}
Producción :
I am a static function.
Imagina tener que usar function1() varias veces a lo largo del programa. Tenemos que escribir NameSpace1.SampleClass.function1 cada vez.
Pero ahora podemos llamarlo por su nombre. Para más profundidad, puede ver using directiva en C#.