Псевдоним пространства имен C # - какой смысл?

Question

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

 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 в одном и том же файле, вам придется продолжать давать полные имена (поскольку 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

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

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 3

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

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 4

Краткость.

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

Answer 5

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

using Utility = MyBaseNamespace.MySubNamsepace.Utility;

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

Answer 6

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

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 7

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

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 8

С одной стороны, это действительно удобно при кодировании в Visual Studio.

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

using System.Data;

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

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

using SqlDataCon = System.Data.SqlClient.SqlConnection

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

Answer 9

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

Если вы указали 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 #, но псевдонимы пространства имен кажутся мне "лучшей практикой". Таким образом, вы знаете, что получаете, и все равно не должны печатать слишком много.

Answer 10

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

MyClass myClassUT;

будучи myClassUT субъектом U nder T est. Но что, если вы хотите написать модульные тесты для статического класса со статическими методами? Затем вы можете создать псевдоним:

using MyStaticClassUT = Namespace.MyStaticClass;

Тогда вы можете написать свои тесты следующим образом:

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

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