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

¿Dónde o cuándo se usaría un alias 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 idioma.

Es un alias de tipo, no un alias de espacio de nombres; es útil eliminar la ambigüedad, por ejemplo, contra:

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

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

De lo contrario, si usa ambos System.Windows.Forms.Timery System.Timers.Timeren el mismo archivo, tendrá que seguir dando los nombres completos (ya que Timerpodría ser confuso).

También juega un papel con los externalias para usar tipos con el mismo nombre de tipo completamente calificado de diferentes ensamblajes; poco común, pero útil para ser compatible.

En realidad, puedo ver otro uso: cuando desea acceso rápido a un tipo, pero no desea usar un tipo regular usingporque no puede importar algunos métodos de extensión en conflicto ... 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 varios espacios de nombres con subespacios de nombres y / o nombres de objetos en conflicto, podría hacer algo como [como 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 lo contrario 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 un montón de escritura 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 tipos (en lugar de los alias de espacios de nombres) pueden ser útiles cuando se hace referencia repetidamente a tipos genéricos:

Dictionary<string, SomeClassWithALongName> foo = new Dictionary<string, SomeClassWithALongName>();

private void DoStuff(Dictionary<string, SomeClassWithALongName> dict) {}

Versus:

using FooDict = Dictionary<string, SomeClassWithALongName>;

FooDict foo = new FooDict();

private void DoStuff(FooDict dict) {}

Brevedad.

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

Siempre lo uso en situaciones como esta

using Utility = MyBaseNamespace.MySubNamsepace.Utility;

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

Es muy útil cuando tiene varias clases con el mismo nombre en varios 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 feliz al compilador y dejar las cosas más claras para usted y otros miembros de 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 espacios 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 se deben nombrar los alias y cómo todos los están usando.

Encuentro los alias muy útiles en las pruebas unitarias. Cuando está escribiendo pruebas unitarias, es una práctica común declarar la materia a evaluar como

MyClass myClassUT;

siendo myClassUTel sujeto U nder T est. Pero, ¿qué pasa 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 unitarias así:

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

y nunca pierdes de vista cuál es el tema bajo prueba.

En cierto modo, es muy útil al codificar en Visual Studio.

Caso de uso : digamos que tengo que usar solo unas pocas clases, por ejemplo, SqlConnectionde un espacio de nombres System.Data. En el curso normal, importaré el System.Data.SqlClientespacio de nombres en la parte superior del archivo * .cs como se muestra a continuación:

using System.Data;

Ahora mira mi intellisense. Está muy proliferado con una gran cantidad de clases para elegir mientras escribe en el editor de código. No voy a usar un montón de clases en absoluto:

Entonces prefiero usar un alias en la parte superior de mi archivo * .cs y obtener una vista clara de intellisense:

using SqlDataCon = System.Data.SqlClient.SqlConnection

Ahora mira mi vista intellisense. Es superclaro y superlimpio.

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 accede a acceder ModifierKeys, puede encontrar que el nombre ModifierKeysestá en los espacios de nombres System.Windows.Forms.Controly System.Windows.Input. Entonces, al declarar using Input = System.Windows.Input;que puede obtener System.Windows.Input.ModifierKeysvia Input.ModifierKeys.

No soy un aficionado a C #, pero crear un alias en el espacio de nombres me parece la "mejor práctica". De esa manera, sabrá lo que obtiene y aún así no tendrá que escribir mucho más.

Puede usarlos para modificar un código muy fácilmente.

Por ejemplo:

#if USE_DOUBLES
using BNumber = System.Double;
#else
using BNumber = System.Single;
#endif

public void BNumber DoStuff(BNumber n) {
    // ...
}
public void BNumber DoStuff2(BNumber n) {
    // ...
}
public void BNumber DoStuff3(BNumber n) {
    // ...
}

Con el simple cambio de la directiva, puede decidir si todo su código funciona en floato double.