C # ad alanı diğer adı - ne anlamı var?

Ad alanı takma adı nerede veya ne zaman kullanılır?

 using someOtherName =  System.Timers.Timer;

Bana öyle geliyor ki, bu sadece dili anlamaya daha fazla kafa karışıklığı katacak.

Bu bir tür diğer adıdır, ad alanı diğer adı değildir; netleştirmek yararlıdır - örneğin:

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

(ps: Timer;-p seçimi için teşekkürler )

Aksi takdirde, ikisini birden System.Windows.Forms.Timerve System.Timers.Timeraynı dosyada kullanırsanız, tam adları vermeye devam etmeniz gerekir (çünkü Timerkafa karıştırıcı olabilir).

Ayrıca extern, farklı derlemelerden aynı tam nitelikli tür adına sahip türleri kullanmak için diğer adlarla bir rol oynar - nadirdir, ancak desteklenmeleri yararlıdır.

Aslında, başka bir kullanım görebiliyorum: bir türe hızlı erişim istediğinizde, ancak usingbazı çakışan uzantı yöntemlerini içe aktaramadığınız için normal kullanmak istemediğinizde ... biraz kıvrımlı, ancak ... işte bir örnek ...

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

Çakışan alt ad alanlarına ve / veya nesne adlarına sahip birden fazla ad alanım olduğunda bunu kullanıyorum, şöyle bir şey yapabilirsiniz [örnek olarak]:

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

...

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

Aksi takdirde yazılması gereken:

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

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

Bir ton yazma tasarrufu sağlar ve kodun okunmasını çok daha kolay hale getirmek için kullanılabilir.

Belirtilen örneklere ek olarak, tür takma adları (ad alanı takma adları yerine) genel türlere tekrar tekrar atıfta bulunurken kullanışlı olabilir:

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

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

Karşı:

using FooDict = Dictionary<string, SomeClassWithALongName>;

FooDict foo = new FooDict();

private void DoStuff(FooDict dict) {}

Kısalık.

Tür adlarını paylaşan ad alanları arasında netlik sağlamanın yan yararları vardır, ancak esasen sadece şekerdir.

Her zaman böyle durumlarda kullanırım

using Utility = MyBaseNamespace.MySubNamsepace.Utility;

nerede Utilityaksi (gibi farklı bir bağlam olurdu MyBaseNamespace.MySubNamespace.MySubSubNamespace.Utility), ancak beklediğim / tercih Utilityolduğunu belirli bir sınıfa her zaman noktaya kadar.

Birden çok dahil edilen ad alanında aynı ada sahip birden çok sınıfınız olduğunda çok kullanışlıdır. Örneğin...

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

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

Derleyiciyi mutlu etmek ve sizin ve ekibinizdeki diğer kişiler için işleri daha net hale getirmek için takma adlar kullanabilirsiniz:

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

/* ... */

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

Tüm ad alanlarımız için ad alanı takma adları tanımladık. Bu, bir sınıfın nereden geldiğini görmeyi çok kolaylaştırır, örneğin:

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.

ve

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

Takma adların nasıl adlandırılması gerektiğini ve herkesin bunları nasıl kullandığını bazı yönergeler tanımladık.

Takma adları birim testinde çok yararlı buluyorum. Birim testleri yazarken, test edilecek konuyu şu şekilde beyan etmek yaygın bir uygulamadır:

MyClass myClassUT;

olmanın myClassUTKonuyla U nder, T Statik yöntemlerle statik sınıf için yazma ünite testleri istiyorsanız est. Ama ne? Sonra bunun gibi bir takma ad oluşturabilirsiniz:

using MyStaticClassUT = Namespace.MyStaticClass;

Daha sonra birim testlerinizi şu şekilde yazabilirsiniz:

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

ve test edilen konunun ne olduğunu asla gözden kaçırmazsınız.

Bir şekilde Visual Studio'da kodlama yaparken gerçekten kullanışlıdır.

Kullanım durumu : Diyelim ki, örneğin SqlConnectionbir ad alanından sadece birkaç sınıf kullanmalıyım System.Data. Normalde, System.Data.SqlClientaşağıda gösterildiği gibi * .cs dosyasının en üstündeki ad alanını içe aktaracağım:

using System.Data;

Şimdi zekama bak. Kod düzenleyicide yazarken aralarından seçim yapabileceğiniz çok sayıda sınıfla yoğun bir şekilde çoğalmıştır. Bir grup dersi hiç kullanmayacağım:

Bu nedenle, * .cs dosyamın en üstünde bir takma ad kullanmayı ve net bir akıllı görünüm elde etmeyi tercih ederim:

using SqlDataCon = System.Data.SqlClient.SqlConnection

Şimdi entelektüel görüşüme bakın. Süper net ve süper temiz.

Bilmemin bir nedeni; İçe aktarılan ad alanlarından ad çakışmaları olduğunda daha kısa adlar kullanmanıza izin verir. Misal:

Eğer beyan ederse using System.Windows.Forms;ve using System.Windows.Input; aynı dosyada erişmeye gittiğinizde ModifierKeysO ismi bulabileceğiniz ModifierKeysher ikisinde de var System.Windows.Forms.Controlve System.Windows.Inputad. Bildirerek Yani using Input = System.Windows.Input;o zaman alabilirsiniz System.Windows.Input.ModifierKeysyoluyla Input.ModifierKeys.

Ben bir C # tutkunu değilim, ancak ad alanı takma adı bana "en iyi uygulama" gibi görünüyor. Bu şekilde ne elde ettiğinizi bilirsiniz ve yine de çok fazla yazmak zorunda kalmazsınız.

Bir kodu çok kolay bir şekilde değiştirmek için bunları kullanabilirsiniz.

Örneğin:

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

Yönergenin basit bir şekilde değiştirilmesiyle, kodunuzun tamamının içinde floatmi çalışacağına karar verebilirsiniz double.