Alias ​​dello spazio dei nomi C #: qual è il punto?

Dove o quando si utilizzerebbe l'alias dello spazio dei nomi come

 using someOtherName =  System.Timers.Timer;

Mi sembra che aggiungerebbe solo più confusione alla comprensione della lingua.

Questo è un alias di tipo, non un alias di spazio dei nomi; è utile chiarire le ambiguità, ad esempio contro:

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

(ps: grazie per la scelta di Timer;-p)

Altrimenti, se usi entrambi System.Windows.Forms.Timere System.Timers.Timernello stesso file dovresti continuare a dare i nomi completi (poiché Timerpotrebbe creare confusione).

Svolge anche un ruolo con gli externalias per l'utilizzo di tipi con lo stesso nome di tipo completo da diversi assembly: raro, ma utile per essere supportato.

In realtà, posso vedere un altro uso: quando vuoi un accesso rapido a un tipo, ma non vuoi usare un normale usingperché non puoi importare alcuni metodi di estensione in conflitto ... un po 'contorto, ma ... ecco un esempio ...

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 quando ho più spazi dei nomi con sottospazi dei nomi e / o nomi di oggetti in conflitto, potresti semplicemente fare qualcosa come [come esempio]:

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

...

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

Che altrimenti dovrebbe essere scritto:

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

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

Risparmia un sacco di digitazione e può essere utilizzato per rendere il codice molto più facile da leggere.

Oltre agli esempi citati, gli alias di tipo (piuttosto che gli alias dello spazio dei nomi) possono essere utili quando si fa ripetutamente riferimento a tipi generici:

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

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

Contro:

using FooDict = Dictionary<string, SomeClassWithALongName>;

FooDict foo = new FooDict();

private void DoStuff(FooDict dict) {}

Brevità.

Ci sono vantaggi collaterali per fornire chiarezza tra gli spazi dei nomi che condividono i nomi dei tipi, ma essenzialmente è solo zucchero.

Lo uso sempre in situazioni come questa

using Utility = MyBaseNamespace.MySubNamsepace.Utility;

dove Utilityaltrimenti avrebbe un contesto diverso (come MyBaseNamespace.MySubNamespace.MySubSubNamespace.Utility), ma mi aspetto / preferisco Utilitypuntare sempre a quella particolare classe.

È molto utile quando si hanno più classi con lo stesso nome in più spazi dei nomi inclusi. Per esempio...

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

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

Puoi utilizzare gli alias per rendere felice il compilatore e per rendere le cose più chiare per te e per gli altri membri del tuo team:

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

/* ... */

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

Abbiamo definito alias dello spazio dei nomi per tutti i nostri spazi dei nomi. Questo rende molto facile vedere da dove proviene una classe, ad esempio:

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

Abbiamo definito alcune linee guida su come denominare gli alias e tutti li utilizzano.

Trovo gli alias molto utili nei test unitari. Quando si scrivono unit test, è pratica comune dichiarare l'oggetto da testare come

MyClass myClassUT;

essendo myClassUTil soggetto U nder T est. Ma cosa succede se si desidera scrivere unit test per una classe statica con metodi statici? Quindi puoi creare un alias come questo:

using MyStaticClassUT = Namespace.MyStaticClass;

Quindi puoi scrivere i tuoi unit test in questo modo:

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

e non perdi mai di vista quale sia il soggetto in esame.

In un certo senso è davvero utile durante la codifica in Visual Studio.

Caso d'uso : diciamo che devo usare solo poche classi, ad esempio SqlConnectionda uno spazio dei nomi System.Data. In genere, importerò lo System.Data.SqlClientspazio dei nomi nella parte superiore del file * .cs come mostrato di seguito:

using System.Data;

Ora guarda il mio intellisenso. È fortemente proliferato con un sacco di classi tra cui scegliere durante la digitazione nell'editor di codice. Non userò affatto un sacco di classi:

Quindi preferirei utilizzare un alias nella parte superiore del mio file * .cs e ottenere una chiara visualizzazione intellisense:

using SqlDataCon = System.Data.SqlClient.SqlConnection

Ora guarda il mio punto di vista intellettuale. È super chiaro e super pulito.

Un motivo lo so; Ti consente di utilizzare nomi più brevi quando hai conflitti di nomi da spazi dei nomi importati. Esempio:

Se hai dichiarato using System.Windows.Forms;e using System.Windows.Input; nello stesso file quando si va a l'accesso ModifierKeyssi potrebbe scoprire che il nome ModifierKeysè in entrambi i System.Windows.Forms.Controle System.Windows.Inputspazi dei nomi. Quindi dichiarando using Input = System.Windows.Input;che puoi quindi ottenere System.Windows.Input.ModifierKeysvia Input.ModifierKeys.

Non sono un appassionato di C # ma lo spazio dei nomi aliasing mi sembra una "best practice". In questo modo sai cosa stai ricevendo e non devi ancora digitare troppo.

Puoi usarli per modificare un codice molto facilmente.

Per esempio:

#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 la semplice modifica della direttiva puoi decidere se l'intero codice funziona in floato double.