Convertir Enum en Ssortingng

Quelle est la méthode préférée pour convertir un Enum en Ssortingng dans .NET 3.5?

  • Enum.GetName
  • Enum.Format
  • toChaine

Pourquoi devrais-je préférer l’un de ceux-ci aux autres? Est-ce qu’on fait mieux?

A partir de C # 6, le meilleur nom pour obtenir le nom d’une enum est le nouveau nameof opérateur:

 nameof(MyEnum.EnumValue); // Ouputs > "EnumValue" 

Cela fonctionne au moment de la compilation, l’énumération étant remplacée par la chaîne dans le résultat compilé, ce qui signifie que c’est le moyen le plus rapide possible.

Toute utilisation de noms enum interfère avec l’obscurcissement du code, si vous considérez que l’obscurcissement des noms enum vaut la peine ou est important – c’est probablement une toute autre question.

Fonctionne pour notre projet …

 public static Ssortingng convertToSsortingng(this Enum eff) { return Enum.GetName(eff.GetType(), eff); } public static EnumType converToEnum(this Ssortingng enumValue) { return (EnumType) Enum.Parse(typeof(EnumType), enumValue); } 

Tout cela finit en interne d’appeler une méthode appelée InternalGetValueAsSsortingng . La différence entre ToSsortingng et GetName serait que GetName doit d’abord vérifier quelques points:

  1. Le type que vous avez entré n’est pas nul.
  2. Le type que vous avez entré est en fait une énumération.
  3. La valeur que vous avez transmise n’est pas nulle.
  4. La valeur que vous avez transmise est d’un type qu’une énumération peut réellement utiliser comme type sous-jacent ou du type de l’énumération elle-même. Il utilise GetType sur la valeur pour vérifier cela.

.ToSsortingng n’a pas à s’inquiéter de ces problèmes, car il est appelé sur une instance de la classe elle-même et non sur une version passée, par conséquent, la méthode .ToSsortingng n’a pas les mêmes problèmes de vérification que les méthodes statiques, je conclurais que .ToSsortingng est le moyen le plus rapide d’obtenir la valeur sous forme de chaîne.

Dans mes tests, Enum.GetName était plus rapide et avec une marge décente. En interne ToSsortingng appelle Enum.GetName . De la source pour .NET 4.0, l’essentiel:

 public override Ssortingng ToSsortingng() { return Enum.InternalFormat((RuntimeType)GetType(), GetValue()); } private static Ssortingng InternalFormat(RuntimeType eT, Object value) { if (!eT.IsDefined(typeof(System.FlagsAtsortingbute), false)) { Ssortingng retval = GetName(eT, value); //<== the one if (retval == null) return value.ToString(); else return retval; } else { return InternalFlagsFormat(eT, value); } } 

Je ne peux pas dire que c'est la raison, mais les tests de l'état un est plus rapide que l'autre. Les deux appels impliquent la boxe (en fait, ils sont des appels de reflection, vous récupérez essentiellement des noms de champs) et peuvent être lents à votre goût.

Configuration du test : enum avec 8 valeurs, non. des itérations = 1000000

Résultat : Enum.GetName => 700 ms, ToSsortingng => 2000 ms

Si la vitesse n'est pas perceptible, je ne me soucierais pas d'utiliser ToSsortingng car il offre un appel beaucoup plus propre. Contraste

 Enum.GetName(typeof(Bla), value) 

avec

 value.ToSsortingng() 

Le mieux que je puisse trouver est cette question sans rapport sur MSDN , qui contient un fragment de code XML qui répond à cette question. Toutes ces méthodes partagent la même faille: elles appellent enum.toSsortingng() , qui ne fonctionne pas correctement lors de l’utilisation de Dotfuscation . D’autres préoccupations semblent concerner la boxe indirecte (GetName et Format). Malheureusement, je ne trouve aucune raison de performance pour utiliser l’un des éléments ci-dessus.

Paraphraser à partir de l’ extrait de code XML ,

Passer une énumération en boîte à ssortingng.Format () ou à toute autre fonction peut entraîner l’ enum.ToSsortingng() de enum.ToSsortingng() . Cela causera des problèmes lors de la dotfuscating. Vous ne devez pas utiliser enum.ToSsortingng() , enum.GetNames() , enum.GetName() , enum.Format() ou enum.Parse() pour convertir un enum en chaîne. Utilisez plutôt une instruction switch et internationalisez les noms si nécessaire.

Enum.GetName()

Format() n’est en réalité qu’une enveloppe autour de GetName() avec certaines fonctionnalités de formatage (ou InternalGetValueAsSsortingng() pour être exact). ToSsortingng() est pratiquement identique à Format() . Je pense que GetName() est la meilleure option car il est tout à fait évident de savoir ce que cela fait pour quiconque lit la source.

Enum.GetName (…)

C’est la méthode la plus élégante qui lui est destinée.

 var enumValueSsortingng = Enum.GetName(typeof (MyEnum), MyEnum.MyValue); 

Bien que je ne vois aucun problème à appeler .ToSsortingng() car il est simplement plus court.

 var enumValueSsortingng = MyEnum.MyValue.ToSsortingng(); 

Avec la nouvelle syntaxe C # 6, vous pouvez utiliser:

 nameof(MyEnum.MyValue) 

Je crée une méthode d’extension “Description” et je l’attache à l’énumération pour que je puisse obtenir une dénomination vraiment conviviale qui inclut les espaces et les boîtiers. Je n’ai jamais aimé utiliser la valeur enum elle-même en tant que texte affichable car c’est une chose que les développeurs utilisent pour créer un code plus lisible. Il n’est pas destiné à des fins d’affichage d’interface utilisateur. Je veux pouvoir changer l’interface utilisateur sans avoir à passer et à changer d’énumération.

Je ne sais pas quelle est la méthode “préférée” (demandez à 100 personnes et obtenez 100 opinions différentes) mais faites ce qui est le plus simple et ce qui fonctionne. GetName fonctionne mais nécessite beaucoup plus de frappes. ToSsortingng() semble très bien faire le travail.

Cela fonctionnerait aussi.

  List names = Enum.GetNames(typeof(MyEnum)).ToList(); 

Pour les aficionados de VB:

 EnumSsortingngValue = System.Enum.GetName(GetType(MyEnum), MyEnumValue) 

Simple: enum noms dans une liste:

 List NameList = Enum.GetNames(typeof(YourEnumName)).Cast().ToList()