Conventions d'alias de type / espace de noms en C #

Sont là sont des noms ou des conventions de codage pour la définition espace de noms ou de type alias en C#?

Pour ceux qui l'ignorent, le langage C# a une fonction où les alias peuvent être locales définies dans un fichier pour les espaces de noms et les types. Cela peut être utile quand il y a des conflits de noms avec des bibliothèques tierces ainsi que pour raccourcir les noms de type au sein de votre code. Ci-dessous est un exemple de ce à quoi il ressemble.

using Forms = System.Windows.Forms;

La plupart des exemples que j'ai vu sur le web ont tendance à utiliser non capitalisés noms d'alias tels que les alias Formes dans l'exemple ci-dessus. Dans certains endroits, y compris la officiel page MSDN qui explique exemple avec un alias de colAlias pour l'espace de noms Système.Collections. Pour le rendre plus compliqué il y a peut être une préférence pour certains de choisir des critères différents selon que l'espace de noms d'alias ou un alias de type est en cours de définition.

Afin de donner un peu de fond de pourquoi je suis intéressé toutes les lignes directrices avec les noms d'alias, je vais vous expliquer ce que je fais. Dans un projet récent, j'ai commencé à la simplification d'un modèle où j'ai plusieurs classes qui héritent d'une classe générique de base qui accepte de type complexe arguments en utilisant des types d'alias.

Donc, en utilisant cette technique, le complexe de l'exemple ci-dessous devient beaucoup plus lisible une fois le type d'alias sont appliquées.

public class MyClass: MyGenericBaseClass<TripleLindyFancyAlgorithm<List<SomeValueType>>, List<SomeValueType>>
{
    public override List<SomeValueType> DoSomething(TripleLindyFancyAlgorithm<List<SomeValueType>> operation)
    {
        //...
    }
 }

Et en dessous de la doit cleaner version à l'aide de types d'alias.

using Result = List<SomeValueType>;
using Algorithm = TripleLindyFancyAlgorithm<List<SomeValueType>>; //Note: cannot reference an alias within an alias definition!

public class MyClass: MyGenericBaseClass<Algorithm, Result>
{
    public override Result DoSomething(Algorithm operation)
    {
        //...
    }
 }

Bien que cela semble beaucoup plus simpliste, il est facile d'oublier qu'un alias comme Résultat est en fait qu'un alias de la Liste et qu'il n'existe pas de type de Résultat. Afin de séparer les concepts visuellement je suis en train d'étudier à la suite de certains préfixant convention similaire à l'utilisation de l'underscore '_' avant privés membres afin de les aider à distinguer les types d'alias de types réels. Avant de me le faire mais je tiens à vous assurer que je ne suis pas réinventer la roue car peut-être qu'il y a déjà plus de conventions établies.

source d'informationauteur

alias c#namespaces naming-conventions

9

De l'espace de noms d'alias ne sont pas une caractéristique commune de la plupart des bases de code - la dernière place quand je l'ai utilisé, le développeur senior était pas familier avec elle, tout en ayant travaillé avec C# pour de nombreuses années.

Car il est rare, les conventions n'ont pas été développées.

Je dirais que si vous allez utiliser des alias, en discuter avec votre équipe pour créer votre propre convention.

Plusieurs façons différentes, j'ai vu alias utilisés:
- Un acronyme de l'espace de noms. Habituellement, les chapiteaux de l'espace de noms.
- La fin de l'espace de noms - si le pluriel de-la marque du pluriel.
- Un descriptif court nom.
14

Je tiens seulement à utiliser des alias dans le cas de l'espace de noms de conflit (c'est à dire que si je avait).

Pour moi au moins, toute autre utilisation est juste confus et une distraction.
6

Personnellement, je l'utilise uniquement pour garder intelli-sense propre.
```
using StringBuilder = System.Text.StringBuilder;
```
Si vous renommez les types d'ouvrir la boîte de Pandore pour l'entretien des programmeurs.
4

Les deux les cas les plus courants de l'espace de noms d'alias sont:
1. Je l'ai vu et je l'utilise (en tendance)
2. J'port de code à partir d'une autre langue
Pour le premier cas, pas de commentaire. Pour le second, un bon exemple est le portage de code C et l'utilisation de l'espace de noms d'alias pour des raisons pratiques comme:
```
using i64 = System.Int64;
using u8 = System.Byte;
using u32 = System.UInt32;
using u64 = System.UInt64;
```
Même si vous vous considérez le au-dessus d'alias que la programmation différée, ils aident à éviter les erreurs.
2

Je pense que les gens qui sont enclins à ne pas les utiliser à tous les sont donner la réponse que vous avez demandé. Que est la convention. Ce n'est pas à dire qu'il ne peut pas être utile, mais ne l'utilisez pas reste la norme.
2

Vous pourriez adopter une convention pour les utiliser pour l'abstraction.
```
using Id = System.Int32;
```
De cette façon, vous pouvez facilement remplacer cette ligne avec
```
using Id = System.Guid;
```
à un certain point, et aucun autre code n'aurait à changer (en supposant que vous n'avez pas jeté un coup d'oeil par le biais de l'abstraction de créer des dépendances sur le type réel...)
0

En général, je les utiliser uniquement quand j'ai besoin d'utiliser deux nommés de la même façon classes dans les différents espaces de noms, et ne veulent pas entièrement spécifier le type dans le code:
```
using xItem = My.Project.NameSpace.Item;
using yItem = Your.ThirdParty.Framework.Item;
```

Vous devez vous connecter pour publier un commentaire.