Alias ​​del espacio de nombres de C #: ¿cuál es el punto?

He estado tratando de aprender más sobre el lenguaje C #, pero no he podido ver una situación en la que uno use aliasing de espacio de nombres como

using someOtherName = System.Timers.Timer; 

Me parece que solo agregaría más confusión a la comprensión del lenguaje. ¿Podría alguien explicar por favor?

Gracias

Es un alias de tipo, no un alias de espacio de nombres; es útil para desambiguar, por ejemplo, contra:

 using WinformTimer = System.Windows.Forms.Timer; using ThreadingTimer = System.Threading.Timer; 

(pd: gracias por la elección de Timer ;-p)

De lo contrario, si usa System.Windows.Forms.Timer y System.Timers.Timer en el mismo archivo, debería seguir dando los nombres completos (ya que Timer podría ser confuso).

También desempeña un papel con alias extern para el uso de tipos con el mismo nombre de tipo totalmente calificado de diferentes ensamblajes, raros pero útiles para ser compatibles.


En realidad, puedo ver otro uso: cuando quieres un acceso rápido a un tipo, pero no quieres usar un uso regular porque no puedes importar algunos métodos de extensión conflictivos … un poco complicado, pero … aquí hay un ejemplo…

 namespace RealCode { //using Foo; // can't use this - it breaks DoSomething using Handy = Foo.Handy; using Bar; static class Program { static void Main() { Handy h = new Handy(); // prove available string test = "abc"; test.DoSomething(); // prove available } } } namespace Foo { static class TypeOne { public static void DoSomething(this string value) { } } class Handy {} } namespace Bar { static class TypeTwo { public static void DoSomething(this string value) { } } } 

Lo uso cuando tengo múltiples espacios de nombres con espacios de nombres secundarios y / o nombres de objeto en conflicto, podría hacer algo como [como un ejemplo]:

 using src = Namespace1.Subspace.DataAccessObjects; using dst = Namespace2.Subspace.DataAccessObjects; ... src.DataObject source = new src.DataObject(); dst.DataObject destination = new dst.DataObject(); 

Que de otro modo tendría que escribirse:

 Namespace1.Subspace.DataAccessObjects.DataObject source = new Namespace1.Subspace.DataAccessObjects.DataObject(); Namespace2.Subspace.DataAccessObjects.DataObject dstination = new Namespace2.Subspace.DataAccessObjects.DataObject(); 

Ahorra una tonelada de tipeo y se puede usar para hacer que el código sea mucho más fácil de leer.

Además de los ejemplos mencionados, los alias de tipo (en lugar de alias de espacio de nombres) pueden ser útiles cuando se hace referencia repetidamente a tipos generics:

 Dictionary foo = new Dictionary(); private void DoStuff(Dictionary dict) {} 

Versus:

 using FooDict = Dictionary; FooDict foo = new FooDict(); private void DoStuff(FooDict dict) {} 

Siempre lo uso en situaciones como esta

 using Utility = MyBaseNamespace.MySubNamsepace.Utility; 

donde Utility tendría un contexto diferente (como MyBaseNamespace.MySubNamespace.MySubSubNamespace.Utility ), pero espero / prefiero que Utility siempre apunte a esa clase en particular.

Brevedad.

Existen beneficios adicionales para proporcionar claridad entre los espacios de nombres que comparten nombres de tipos, pero esencialmente es solo azúcar.

Es muy útil cuando tienes múltiples clases con el mismo nombre en múltiples espacios de nombres incluidos. Por ejemplo…

 namespace Something.From.SomeCompanyA { public class Foo { /* ... */ } } namespace CompanyB.Makes.ThisOne { public class Foo { /* ... */ } } 

Puede usar alias para hacer que el comstackdor sea feliz y para aclarar las cosas para usted y los demás en su equipo:

 using CompanyA = Something.From.CompanyA; using CompanyB = CompanyB.Makes.ThisOne; /* ... */ CompanyA.Foo f = new CompanyA.Foo(); CompanyB.Foo x = new CompanyB.Foo(); 

Hemos definido alias de espacio de nombres para todos nuestros espacios de nombres. Esto hace que sea muy fácil ver de dónde viene una clase, por ejemplo:

 using System.Web.WebControls; // lots of other using statements // contains the domain model for project X using dom = Company.ProjectX.DomainModel; // contains common web functionality using web = Company.Web; // etc. 

y

 // User from the domain model dom.User user = new dom.User(); // Data transfer object dto.User user = new dto.User(); // a global helper class utl.SomeHelper.StaticMethod(); // a hyperlink with custom functionality // (as opposed to System.Web.Controls.HyperLink) web.HyperLink link = new web.HyperLink(); 

Hemos definido algunas pautas sobre cómo deben nombrarse los alias y todos los usan.

De alguna manera, es muy útil al codificar en Visual Studio.

Caso de uso : digamos que debo usar solo algunas clases, por ejemplo, SqlConnection desde un espacio de nombres System.Data . En el curso normal, importaré el espacio de nombres System.Data.SqlClient en la parte superior del archivo * .cs como se muestra a continuación:

 using System.Data; 

Ahora mira mi intellisense. Está muy proliferado con muchas clases para elegir al escribir en el editor de código. No voy a usar un montón de clases en absoluto:

enter image description here

Así que preferiría usar un alias en la parte superior de mi archivo * .cs y obtener una clara visión de Intellisense:

 using SqlDataCon = System.Data.SqlClient.SqlConnection 

Ahora mira mi punto de vista intellisense. Es súper claro y súper limpio.

enter image description here

Encuentro que los alias son muy útiles en las pruebas unitarias. Cuando está escribiendo pruebas unitarias, es una práctica común declarar el sujeto a prueba como

 MyClass myClassUT; 

siendo myClassUT el sujeto en T est. Pero, ¿y si quieres escribir pruebas unitarias para una clase estática con métodos estáticos? Entonces puedes crear un alias como este:

 using MyStaticClassUT = Namespace.MyStaticClass; 

Entonces puedes escribir tus pruebas de unidad así:

 public void Test() { var actual = MyStaticClassUT.Method(); var expected = ... } 

y nunca pierdes de vista lo que es el sujeto bajo prueba.

Una razón por la que sé; Le permite usar nombres más cortos cuando tiene colisiones de nombres de espacios de nombres importados. Ejemplo:

Si declaró using System.Windows.Forms; y using System.Windows.Input; en el mismo archivo cuando vaya a acceder a ModifierKeys , puede encontrar que el nombre ModifierKeys está en los espacios de nombres System.Windows.Forms.Control y System.Windows.Input . Entonces al declarar using Input = System.Windows.Input; puede obtener System.Windows.Input.ModifierKeys través de Input.ModifierKeys .

No soy un fanático de C #, pero el espacio de nombres de alias me parece una “mejor práctica”. De esa forma sabrá lo que está recibiendo y, sin embargo, no tendrá que escribir mucho más.