C # alias namespace - apa gunanya?

Di mana atau kapan seseorang akan menggunakan namespace aliasing seperti

 using someOtherName =  System.Timers.Timer;

Bagi saya sepertinya itu hanya akan menambah kebingungan untuk memahami bahasa.

Itu adalah tipe alias, bukan alias namespace; berguna untuk membedakan - misalnya, melawan:

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

(ps: terima kasih untuk pilihan Timer;-p)

Jika tidak, jika Anda menggunakan keduanya System.Windows.Forms.Timerdan System.Timers.Timerdalam file yang sama, Anda harus tetap memberikan nama lengkap (karena Timerbisa membingungkan).

Ini juga berperan dengan externalias untuk menggunakan tipe dengan nama tipe yang sepenuhnya memenuhi syarat dari rakitan yang berbeda - jarang, tetapi berguna untuk didukung.

Sebenarnya, saya dapat melihat penggunaan lain: ketika Anda menginginkan akses cepat ke suatu jenis, tetapi tidak ingin menggunakan yang biasa usingkarena Anda tidak dapat mengimpor beberapa metode ekstensi yang berkonflik ... agak berbelit-belit, tetapi ... berikut contohnya ...

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

Saya menggunakannya ketika saya memiliki beberapa ruang nama dengan sub ruang nama yang bertentangan dan / atau nama objek, Anda dapat melakukan sesuatu seperti [sebagai contoh]:

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

...

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

Yang seharusnya harus ditulis:

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

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

Ini menghemat banyak pengetikan dan dapat digunakan untuk membuat kode lebih mudah dibaca.

Selain contoh yang disebutkan, alias tipe (bukan alias namespace) bisa berguna saat berulang kali merujuk ke tipe generik:

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

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

Melawan:

using FooDict = Dictionary<string, SomeClassWithALongName>;

FooDict foo = new FooDict();

private void DoStuff(FooDict dict) {}

Keringkasan.

Ada manfaat tambahan untuk memberikan kejelasan antara namespace yang memiliki nama tipe yang sama, tetapi pada dasarnya itu hanya gula.

Saya selalu menggunakannya dalam situasi seperti ini

using Utility = MyBaseNamespace.MySubNamsepace.Utility;

dimana Utility seharusnya memiliki konteks yang berbeda (seperti MyBaseNamespace.MySubNamespace.MySubSubNamespace.Utility), tetapi saya berharap / lebih suka Utilityuntuk selalu menunjuk ke satu kelas tertentu.

Ini sangat berguna ketika Anda memiliki beberapa kelas dengan nama yang sama di beberapa ruang nama yang disertakan. Sebagai contoh...

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

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

Anda dapat menggunakan alias untuk membuat kompiler senang dan membuat segalanya lebih jelas untuk Anda dan orang lain di tim Anda:

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

/* ... */

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

Kami telah mendefinisikan alias namespace untuk semua namespace kami. Ini membuatnya sangat mudah untuk melihat dari mana kelas berasal, misalnya:

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.

dan

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

Kami telah menetapkan beberapa pedoman bagaimana alias harus diberi nama dan semua orang menggunakannya.

Saya menemukan alias sangat berguna dalam pengujian unit. Saat Anda menulis tes unit, adalah praktik umum untuk menyatakan subjek yang akan diuji sebagai

MyClass myClassUT;

menjadi myClassUTsubjek U nder T est. Tapi bagaimana jika Anda ingin tes tulis satuan untuk kelas statis dengan metode statis? Kemudian Anda dapat membuat alias seperti ini:

using MyStaticClassUT = Namespace.MyStaticClass;

Kemudian Anda dapat menulis pengujian unit Anda seperti ini:

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

dan Anda tidak akan pernah melupakan subjek yang diuji.

Di satu sisi, ini sangat berguna saat melakukan pengkodean di Visual Studio.

Kasus penggunaan : Katakanlah saya hanya menggunakan beberapa kelas misalnya SqlConnectiondari namespace System.Data. Dalam kursus normal saya akan mengimpor System.Data.SqlClientnamespace di bagian atas file * .cs seperti yang ditunjukkan di bawah ini:

using System.Data;

Sekarang lihat akal sehat saya. Ini sangat berkembang biak dengan banyak kelas untuk dipilih saat mengetik di editor kode. Saya tidak akan menggunakan banyak kelas sama sekali:

Jadi saya lebih suka menggunakan alias di bagian atas file * .cs saya dan mendapatkan tampilan intellisense yang jelas:

using SqlDataCon = System.Data.SqlClient.SqlConnection

Sekarang lihat pandangan akal sehat saya. Ini sangat jernih dan sangat bersih.

Satu alasan saya tahu; Ini memungkinkan Anda menggunakan nama yang lebih pendek saat Anda memiliki benturan nama dari namespace yang diimpor. Contoh:

Jika Anda mendeklarasikan using System.Windows.Forms;dan using System.Windows.Input; dalam file yang sama saat Anda mengaksesnya, ModifierKeysAnda mungkin menemukan bahwa nama ModifierKeystersebut ada di ruang nama System.Windows.Forms.Controldan System.Windows.Input. Jadi dengan mendeklarasikan using Input = System.Windows.Input;Anda kemudian bisa System.Windows.Input.ModifierKeysmelaluiInput.ModifierKeys .

Saya bukan penggemar C # tetapi namespace aliasing sepertinya "praktik terbaik" bagi saya. Dengan begitu Anda tahu apa yang Anda dapatkan dan tetap tidak perlu mengetik terlalu banyak.

Anda dapat menggunakannya untuk mengubah kode dengan sangat mudah.

Sebagai contoh:

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

Dengan perubahan sederhana pada direktif Anda dapat memutuskan apakah seluruh kode Anda berfungsi di floatatau double.