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

95

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.

Brad
fonte
6
Que tal um sistema amplo using int = System.Int32em C #? Útil, não é? É o mesmo uso que pode ser aproveitado em outro lugar.
nawfal
@nawfal Acredito que os aliases de tipo não são exportáveis. O que significa que você não pode definir algo como using int = System.Int32e usá-lo em outros lugares além do arquivo de declaração. Portanto, este inta Int32apelido tanto pode ser alcançado por outros meios, ou é uma coisa especial no compilador / runtime.
KFL
1
@KFL isso é verdade, mas o benefício que ambos oferecem é da mesma natureza.
nawfal
1
@nawfal seu argumento sobre using int = System.Int32está errado e enganoso - está errado porque o intalias não foi implementado da maneira que você descreveu. É enganoso porque você sugere que os aliases de tipo podem ser usados ​​globalmente, assim como o modo como inté usado Int32.
KFL
2
@KFL eu não implicava em ambos. Acabei de declarar por que pode ser útil ter um nome personalizado para um tipo.
nawfal

Respostas:

151

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) { }
    }
}
Marc Gravell
fonte
8
Ele pode ser usado para criar um alias para namespaces ou nomes de tipo.
Sean Bright
1
@Sean: sim, mas o exemplo dado foi para um tipo
Marc Gravell
@lupefiasco: conveniente do OP escolher System.Timers.Timer;-p
Marc Gravell
Ah, pensei que você estava se referindo ao conceito e não ao exemplo específico. Mea culpa.
Sean Bright
26

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.

BenAlabaster
fonte
17

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) {}
Joel Mueller
fonte
8

Brevidade.

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

Annakata
fonte
Mostra claramente qual símbolo você está usando. Não é apenas açúcar, mas um pouco prolixo (se você não quiser definir um novo nome).
Earth Engine de
7

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.

bdukes
fonte
6

É 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();
Sean Bright
fonte
3

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.

M4N
fonte
1
Você não acha que muitas vezes o alias tem mais a ver com o contexto no qual está sendo usado do que com a localização física do objeto?
BenAlabaster
2

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.

Charlie
fonte
2

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:

insira a descrição da imagem aqui

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.

insira a descrição da imagem aqui

RBT
fonte
1

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.

Zv_oDD
fonte
1

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.

Ender Look
fonte