C# namespace alias - в чем смысл?

Question

Я пытался узнать больше о языке С #, но я не был в состоянии увидеть ситуацию, в которой можно было бы использовать пространство имен псевдонимов как

using someOtherName = System.Timers.Timer; 

Мне кажется, что было бы просто добавить больше путаницы к пониманию языка. Может кто-нибудь объяснить.

Благодаря

Answer 1

Это псевдоним типа, а не имена псевдонима; полезно неоднозначность - например, против:

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

(PS: спасибо за выбор Timer ;-p)

В противном случае, если вы используете оба System.Windows.Forms.Timer и System.Timers.Timer в том же файле вы» d должен продолжать давать полные имена (поскольку Timer может ввести в заблуждение).

Он также играет роль с псевдонимами extern для использования типов с таким же полным именем типа из разных сборок - редко, но полезно для поддержки.

---

На самом деле, я вижу еще одно применение: если вы хотите быстрый доступ к типу, но не хотите использовать обычный using, потому что вы не можете импортировать некоторые противоречивые методы расширения ... немного запутанные , но ... вот пример ...

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

Answer 2

это очень полезно, когда у вас есть несколько классов с тем же именем в многокорпусных включены пространства имен. Например ...

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

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

Вы можете использовать псевдонимы, чтобы сделать компилятор счастливым и сделать вещи более ясно для вас и других в вашей команде:

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

/* ... */ 

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

Answer 3

Я всегда использовать его в подобных ситуациях

using Utility = MyBaseNamespace.MySubNamsepace.Utility; 

где Utility иначе пришлось бы другой контекст (как MyBaseNamespace.MySubNamespace.MySubSubNamespace.Utility), но я ожидаю/предпочитаю Utility всегда указывают, что один р суставной класс.

Answer 4

Brevity.

Есть дополнительные преимущества, обеспечивающие ясность между пространствами имен, которые разделяют имена типов, но по сути это просто сахар.

Answer 5

Я использую его, когда у меня есть несколько пространств имен с конфликтующими подразделам пространства имен и/или имена объектов, вы можете просто сделать что-то вроде [как пример]:

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

... 

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

которые в противном случае были бы быть написано:

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

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

Это экономит массу печатей и может быть использовано для упрощения чтения кода.

Answer 6

Мы определили псевдонимы пространства имен для всех наших пространств имен. Это делает его очень легко увидеть, где класс приходит, например:

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. 

и

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

Мы определили некоторые рекомендации, как псевдонимы должны быть названы и все их используют.

Answer 7

В дополнении к примерам, упомянутое, псевдонимы типа (а не пространство имен псевдонимов) может быть удобно, когда несколько раз со ссылкой на общие тип:

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

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

Против:

using FooDict = Dictionary<string, SomeClassWithALongName>; 

FooDict foo = new FooDict(); 

private void DoStuff(FooDict dict) {} 

Answer 8

Я считаю, псевдонимы очень полезен при модульном тестировании. При написании модульных тестов, это обычная практика, чтобы объявить эту тему, чтобы проверить, как

MyClass myClassUT; 

быть myClassUT предметом U NDER T оцен. Но что, если вы хотите, чтобы написать юнит тесты на статический класс со статическими методами? Затем вы можете создать псевдоним, как это:

using MyStaticClassUT = Namespace.MyStaticClass; 

Тогда вы можете написать модульные тесты, как это:

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

, и вы никогда не потерять из виду то, что субъект в испытании.

Answer 9

В одном случае это очень удобно при кодировании в Visual Studio.

Use-case: Скажем, я должен использовать только несколько классов, например. SqlConnection из пространства имен System.Data. В процессе я буду импортировать System.Data.SqlClient имен в верхней части файла * .cs, как показано ниже:

using System.Data; 

Теперь посмотрим на мой IntelliSense. Он сильно размножается со множеством классов на выбор, набирая редактор кода. Я не собираюсь использовать целую кучу классов на всех:

Так что я предпочел бы использовать псевдоним в верхней части моего * .cs файл и получить четкое представление IntelliSense:

using SqlDataCon = System.Data.SqlClient.SqlConnection 

Теперь взгляните на мой взгляд на intellisense. Это супер-чистый и супер-чистый.

Answer 10

Одна из причин, я знаю; Он позволяет использовать более короткие имена, если вы столкнулись с именами из импортированных пространств имен. Пример:

Если вы объявили using System.Windows.Forms; и using System.Windows.Input; в том же файле, когда вы идете, чтобы получить доступ ModifierKeys вы можете обнаружить, что имя ModifierKeys в обоих System.Windows.Forms.Control и System.Windows.Input пространств имен. Итак, объявив using Input = System.Windows.Input;, вы можете получить System.Windows.Input.ModifierKeys через Input.ModifierKeys.

Я не C# бафф, но пространство имен псевдонимов кажется мне «лучшей практикой». Таким образом, вы знаете, что получаете, и все еще не нужно вводить слишком много.