web-dev-qa-db-fra.com

Alias ​​d'espace de noms C # - à quoi ça sert?

J'ai essayé d'en savoir plus sur le langage C #, mais je n'ai pas pu voir une situation où l'on utiliserait un aliasing d'espace de noms comme

 using someOtherName =  System.Timers.Timer;

Il me semble que cela ajouterait simplement plus de confusion à la compréhension de la langue. Quelqu'un pourrait-il expliquer.

Merci

c#namespaces
87
Brad

Il s'agit d'un alias de type, pas d'un alias d'espace de noms; il est utile de lever l'ambiguïté - par exemple, contre:

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

(ps: merci pour le choix de Timer ;-p)

Sinon, si vous utilisez les deux System.Windows.Forms.Timer et System.Timers.Timer dans le même fichier, vous devrez continuer à donner les noms complets (car Timer pourrait être source de confusion).

Il joue également un rôle avec les alias extern pour utiliser des types avec le même nom de type complet à partir d'assemblages différents - rare, mais utile pour être pris en charge.

En fait, je peux voir une autre utilisation: lorsque vous voulez accéder rapidement à un type, mais ne voulez pas utiliser un using régulier parce que vous ne pouvez pas importer des méthodes d'extension conflictuelles ... un peu compliquées, mais ... voici un exemple ...

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) { }
    }
}
142
Marc Gravell

Je l'utilise lorsque j'ai plusieurs espaces de noms avec des sous-espaces de noms et/ou des noms d'objets en conflit, vous pouvez simplement faire quelque chose comme [à titre d'exemple]:

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

...

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

Qui devrait autrement être écrit:

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

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

Il économise une tonne de frappe et peut être utilisé pour rendre le code beaucoup plus facile à lire.

25
BenAlabaster

En plus des exemples mentionnés, les alias de type (plutôt que les alias d'espace de noms) peuvent être utiles lors de la référence répétée à des types génériques:

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

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

Contre:

using FooDict = Dictionary<string, SomeClassWithALongName>;

FooDict foo = new FooDict();

private void DoStuff(FooDict dict) {}
17
Joel Mueller

Brièveté.

Il existe des avantages marginaux pour clarifier les espaces de noms qui partagent des noms de type, mais il s'agit essentiellement de sucre.

8
annakata

Je l'utilise toujours dans des situations comme celle-ci

using Utility = MyBaseNamespace.MySubNamsepace.Utility;

où Utility aurait autrement un contexte différent (comme MyBaseNamespace.MySubNamespace.MySubSubNamespace.Utility), mais je m'attends à/préfère que Utility pointe toujours vers cette classe particulière.

7
bdukes

Il est très utile lorsque vous avez plusieurs classes portant le même nom dans plusieurs espaces de noms inclus. Par exemple...

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

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

Vous pouvez utiliser des alias pour rendre le compilateur heureux et rendre les choses plus claires pour vous et les autres membres de votre équipe:

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

/* ... */

CompanyA.Foo f = new CompanyA.Foo();
CompanyB.Foo x = new CompanyB.Foo();
5
Sean Bright

Nous avons défini des alias d'espace de noms pour tous nos espaces de noms. Cela permet de voir très facilement d'où vient une classe, par exemple:

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.

et

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

Nous avons défini quelques directives sur la façon dont les alias doivent être nommés et tout le monde les utilise.

3
M4N

Dans un sens, c'est vraiment pratique lors du codage dans Visual Studio.

Cas d'utilisation : Disons que je dois utiliser seulement quelques classes par exemple SqlConnection à partir d'un espace de noms System.Data. En temps normal, j'importe le System.Data.SqlClient espace de noms en haut du fichier * .cs comme indiqué ci-dessous:

using System.Data;

Maintenant, regardez mon intellisense. Il est fortement proliféré avec beaucoup de classes à choisir lors de la frappe dans l'éditeur de code. Je ne vais pas utiliser tout un tas de cours:

enter image description here

Je préfère donc utiliser un alias en haut de mon fichier * .cs et obtenir une vue d'intellisense claire:

using SqlDataCon = System.Data.SqlClient.SqlConnection

Maintenant, regardez ma vue intellisense. C'est super clair et super propre.

enter image description here

2
RBT

Une raison que je connais; Il vous permet d'utiliser des noms plus courts lorsque vous avez des collisions de noms à partir d'espaces de noms importés. Exemple:

Si vous avez déclaré using System.Windows.Forms; et using System.Windows.Input; dans le même fichier lorsque vous accédez à ModifierKeys vous constaterez peut-être que le nom ModifierKeys se trouve à la fois dans le System.Windows.Forms.Control et System.Windows.Input espaces de noms. Donc, en déclarant using Input = System.Windows.Input; vous pouvez alors obtenir System.Windows.Input.ModifierKeys via Input.ModifierKeys.

Je ne suis pas un buff C #, mais l'aliasing namespace me semble être la "meilleure pratique". De cette façon, vous savez ce que vous obtenez et vous n'avez toujours pas besoin de taper plus.

1
Zv_oDD

Je trouve les alias très utiles dans les tests unitaires. Lorsque vous écrivez des tests unitaires, il est courant de déclarer le sujet à tester comme

MyClass myClassUT;

étant myClassUT le sujet U nder T est. Mais que faire si vous voulez écrire des tests unitaires pour une classe statique avec des méthodes statiques? Ensuite, vous pouvez créer un alias comme celui-ci:

using MyStaticClassUT = Namespace.MyStaticClass;

Ensuite, vous pouvez écrire vos tests unitaires comme ceci:

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

et vous ne perdez jamais de vue le sujet testé.

1
Charlie