Alias ​​de namespace C # - qual é o ponto?

Onde ou quando alguém usaria alias de namespace, como

 using someOtherName =  System.Timers.Timer;

Parece-me que apenas adicionaria mais confusão para a compreensão da linguagem.

Esse é um alias de tipo, não um alias de namespace; é útil eliminar a ambigüidade - por exemplo, contra:

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

(ps: obrigado pela escolha de Timer ;-p)

Caso contrário, se você usar ambos System.Windows.Forms.Timere System.Timers.Timerno mesmo arquivo, terá que continuar fornecendo os nomes completos (pois Timerpode ser confuso).

Ele também desempenha um papel com externaliases para usar tipos com o mesmo nome de tipo totalmente qualificado de diferentes assemblies - raro, mas útil para ter suporte.

Na verdade, posso ver outro uso: quando você quer acesso rápido a um tipo, mas não quer usar um regular usingporque você não pode importar alguns métodos de extensão conflitantes ... um pouco complicado, mas ... aqui está um exemplo ...

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) { }
    }
}

Eu o uso quando tenho vários namespaces com sub namespaces e / ou nomes de objeto conflitantes, você poderia apenas fazer algo como [por exemplo]:

using src = Namespace1.Subspace.DataAccessObjects;
using dst = Namespace2.Subspace.DataAccessObjects;

...

src.DataObject source = new src.DataObject();
dst.DataObject destination = new dst.DataObject();

O que de outra forma teria que ser escrito:

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

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

Ele economiza uma tonelada de digitação e pode ser usado para tornar o código muito mais fácil de ler.

Além dos exemplos mencionados, aliases de tipo (em vez de aliases de namespace) podem ser úteis ao se referir 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) {}

Brevidade.

Existem benefícios adicionais para fornecer clareza entre namespaces que compartilham nomes de tipo, mas essencialmente é apenas açúcar.

Eu sempre uso em situações como esta

using Utility = MyBaseNamespace.MySubNamsepace.Utility;

onde Utility, de outra forma, teria um contexto diferente (como MyBaseNamespace.MySubNamespace.MySubSubNamespace.Utility), mas espero / prefiro Utilitysempre apontar para essa classe específica.

É muito útil quando você tem várias classes com o mesmo nome em vários namespaces incluídos. Por exemplo...

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

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

Você pode usar aliases para deixar o compilador feliz e tornar as coisas mais claras para você e outras pessoas de sua equipe:

using CompanyA = Something.From.CompanyA;
using CompanyB = CompanyB.Makes.ThisOne;

/* ... */

CompanyA.Foo f = new CompanyA.Foo();
CompanyB.Foo x = new CompanyB.Foo();

Definimos aliases de namespace para todos os nossos namespaces. Isso torna muito fácil ver de onde vem uma aula, por exemplo:

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.

e

// 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(); 

Definimos algumas diretrizes sobre como os apelidos devem ser nomeados e todos os estão usando.

Acho os aliases muito úteis em testes de unidade. Quando você está escrevendo testes de unidade, é uma prática comum declarar o assunto a ser testado como

MyClass myClassUT;

sendo myClassUTo assunto U nder T est. Mas e se você quiser escrever testes de unidade para uma classe estática com métodos estáticos? Então você pode criar um alias como este:

using MyStaticClassUT = Namespace.MyStaticClass;

Então você pode escrever seus testes de unidade assim:

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

e você nunca perde de vista o que é o assunto em teste.

De certa forma, é muito útil ao codificar no Visual Studio.

Caso de uso : digamos que eu precise usar apenas algumas classes, por exemplo, SqlConnectionde um namespace System.Data. No curso normal, importarei o System.Data.SqlClientnamespace na parte superior do arquivo * .cs conforme mostrado abaixo:

using System.Data;

Agora olhe para o meu intelecto. É fortemente proliferado com muitas classes para escolher enquanto digita no editor de código. Não vou usar um monte de classes:

Portanto, prefiro usar um alias na parte superior do meu arquivo * .cs e obter uma visão clara do intellisense:

using SqlDataCon = System.Data.SqlClient.SqlConnection

Agora olhe para a minha visão do intellisense. É super-claro e super-limpo.

Uma razão eu sei; Ele permite que você use nomes mais curtos quando houver conflitos de nomes de namespaces importados. Exemplo:

Se você declarou using System.Windows.Forms;e está using System.Windows.Input; no mesmo arquivo ao acessar, ModifierKeyspoderá descobrir que o nome ModifierKeysestá nos namespaces System.Windows.Forms.Controle System.Windows.Input. Então, ao declarar, using Input = System.Windows.Input;você pode obter System.Windows.Input.ModifierKeysviaInput.ModifierKeys .

Não sou um aficionado por C #, mas criar aliases de namespace parece ser a "melhor prática" para mim. Dessa forma, você sabe o que está recebendo e ainda não precisa digitar muito mais.

Você pode usá-los para modificar um código com muita facilidade.

Por exemplo:

#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) {
    // ...
}

Pela simples mudança na diretiva, você pode decidir se todo o seu código funciona em floatou double.