Convertir Enum à Chaîne

Qui est la meilleure façon de convertir un Enum pour une Chaîne .NET 3.5?

  • Enum.GetName
  • Enum.Format
  • toString

Pourquoi devrais-je préférer l'un de ces plus que les autres? N'est-on effectuer mieux?

  • J'ai cherché et n'a pas pu trouver un duplicata. Si vous pouvez fournir un lien je vais supprimer cette question.
  • parfois, à l'aide d'une instruction switch est pas la meilleure pratique (quand vous avez de grandes énumérations), vous pouvez utiliser Dict<> au lieu de cela
  • Si vous voulez de meilleures performances, vous pouvez utiliser la classe décrite dans cet article codeproject.com/KB/dotnet/enum.aspx. L'utilisation ressemblera à ceci Enum<YourEnum>.ToString(yourValue) ou Enum<YourEnum>.ToString((int)yourValue)
  • Le codage de ne pas casser les dotfuscation est la quintessence de la queue qui remue le chien. SW les producteurs ne sont pas de la pensée, "nous allons faire une grande application pour dotfuscator a quelque chose à faire." Dofuscator existe pour faciliter le développement SW. Si il ne peut pas le faire ... peut-il!
InformationsquelleAutor Eric Weilnau | 2009-01-27
  1. 94

    De C#6 le meilleur moyen d'obtenir le nom d'un enum est le nouveau nameof opérateur:

    nameof(MyEnum.EnumValue);

//Ouputs
> "EnumValue"

    Cela fonctionne au moment de la compilation, avec l'enum d'être remplacé par la chaîne dans le résultat compilé, qui à son tour signifie que ce est la façon la plus rapide possible.

    Toute utilisation d'enum noms d'interférer avec l'obfuscation du code, si vous considérez l'obscurcissement de noms enum intéressant ou important - c'est probablement une toute autre question.

    • Cela mérite plus d'attention. La limite évidente nonobstant, c'est à dire l'obligation pour la compilation d'entrée. À mon avis, cela devrait être préféré chaque fois que possible. "Rename" et "rechercher toutes les références" à prendre en compte, évitant les chaînes magiques et dupliquer des constantes.
    • Donc je suppose qu'Il ne fonctionne pas lorsque la valeur d'enum est défini au moment de l'exécution? Ex: MyEnum variableEnum; variableEnum = setEnumValueMethod(); nameof(variableEnum);
    • non, comme nameof(variableEnum) sera "variableEnum". Il tient (au moment de la construction) le nom de la field/property/param/variable non le valeur.
    InformationsquelleAutor Keith
  2. 91

    Travaille pour notre projet...

    public static String convertToString(this Enum eff)
{
    return Enum.GetName(eff.GetType(), eff);
}

public static EnumType converToEnum<EnumType>(this String enumValue)  
{
    return (EnumType) Enum.Parse(typeof(EnumType), enumValue);
}
    • Enum.GetName prend la valeur d'un objet en argument. Cela signifie que la valeur va être mis en boîte et ce sera le gaspillage de ressources CPU sur la répartition et sur la collecte des ordures. Si cela est fait de beaucoup de temps, Enum.GetName aura beaucoup moins de débit que la mise en cache les valeurs dans un dictionnaire et à la recherche pour le nom.
    • quelle est donc la solution , pour l'utiliser à la place?
    InformationsquelleAutor Sumtraveller
  3. 23

    Dans mes tests, Enum.GetName a été plus rapide et en marge décente. En interne ToString appels Enum.GetName. À partir de la source pour .NET 4.0, l'essentiel:

    public override String ToString()
{
     return Enum.InternalFormat((RuntimeType)GetType(), GetValue());
}

private static String InternalFormat(RuntimeType eT, Object value)
{
    if (!eT.IsDefined(typeof(System.FlagsAttribute), false))
    {
        String 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 pour sûr, mais les tests de l'état est plus rapide que les autres. Les deux appels impliquent de boxe (en fait, ils sont le reflet d'appels, vous êtes essentiellement de la récupération des noms de champ) et peut être lent à votre goût.

    Configuration de Test: enum avec 8 valeurs, pas de. d'itérations = 1000000

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

    Si la vitesse n'est pas perceptible, je n'aurais pas les soins et l'utilisation ToString car il offre un beaucoup plus propre appel. Le contraste

    Enum.GetName(typeof(Bla), value)

    avec

    value.ToString()
    InformationsquelleAutor nawfal
  4. 20

    Tous ces à l'interne retrouvez l'appel d'une méthode appelée InternalGetValueAsString. La différence entre ToString et GetName serait que GetName a pour vérifier quelques choses d'abord:

    1. Le type que vous avez entré n'est pas null.
    2. Le type que vous avez entré est en fait une énumération.
    3. La valeur que vous avez passé n'est pas null.
    4. La valeur passée dans un type qu'une énumération pouvez utiliser comme c'est le type sous-jacent, ou le type de l'énumération lui-même. Il utilise GetType sur la valeur de vérifier cela.

    .ToString n'a pas à se préoccuper de ces questions ci-dessus, car elle est appelée sur une instance de la classe elle-même, et non sur le passé de la version, par conséquent, en raison du fait que le .ToString méthode n'a pas les mêmes problèmes de vérification que les méthodes statiques, j'en conclurai que .ToString est le moyen le plus rapide pour obtenir la valeur sous forme de chaîne.

    • où avez-vous vérifier ces? Quelle était la version de l'assembly? J'obtiens des résultats très différents.
    InformationsquelleAutor David Morton
  5. 16

    Du mieux que je peux trouver est cette question sans rapport, sur MSDN, qui contient un fragment de code XML qui répond à cette question. L'une de ces méthodes partagent le même défaut: ils appellent enum.toString(), qui ne fonctionne pas correctement lors de l'utilisation Dotfuscation. D'autres préoccupations concernent indirects de boxe (GetName et Format). Malheureusement, je ne trouve pas de raisons de performances pour l'utilisation de tout ce qui précède.

    De la paraphrase de la extrait de code xml suivant,

    Passant d'une boîte enum à la chaîne.Format() ou toute autre fonction qui peut entraîner enum.ToString() d'être appelé.
    Cela va entraîner des problèmes lors de Dotfuscating. Vous ne devez pas utiliser enum.ToString(), enum.GetNames(), enum.GetName(), enum.Format() ou enum.Parse() pour convertir un enum pour une chaîne de caractères. Au lieu de cela, utilisez une instruction switch, et également internationaliser les noms si nécessaire.

    InformationsquelleAutor
  6. 16

    Enum.GetName(...)

    C'est le plus élégant de la méthode qui est signifié pour elle.

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

    Bien que je ne vois pas de problèmes avec l'appel de .ToString() comme il est tout simplement plus courte.

    var enumValueString = MyEnum.MyValue.ToString();

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

    nameof(MyEnum.MyValue)
    InformationsquelleAutor Andrei
  7. 15

    Enum.GetName()

    Format() est vraiment juste un wrapper autour de GetName() avec une mise en forme de la fonctionnalité (ou InternalGetValueAsString() pour être exact). ToString() est à peu près le même que Format(). Je pense que GetName() est la meilleure option car il est tout à fait évident qu'il ne l'est pour n'importe qui qui lit la source.

    InformationsquelleAutor Tamas Czinege
  8. 8

    - Je créer une "Description" de la méthode d'extension et de l'attacher à l'enum afin que je puisse obtenir vraiment conviviale de nommage qui comprend des espaces et du boîtier. Je n'ai jamais aimé l'aide de la valeur d'enum comme affichables texte parce que c'est quelque chose que nous avons utilisée par les développeurs pour créer un code plus lisible. Il n'est pas prévu pour l'INTERFACE utilisateur à des fins d'affichage. Je veux être en mesure de modifier l'INTERFACE utilisateur sans passer par et la modification des enums partout.

    InformationsquelleAutor DancesWithBamboo
  9. 6

    Je ne sais pas ce qu'est le "préféré" la méthode est (demandez à 100 personnes et obtenez 100 des opinions différentes), mais de faire ce qui est plus simple et ce qui fonctionne. GetName fonctionne mais nécessite beaucoup plus de frappes. ToString() semble faire le travail très bien.

    InformationsquelleAutor Perry Neal
  10. 0

    Ce serait trop de travail. 

        List<string> names = Enum.GetNames(typeof(MyEnum)).ToList();
    InformationsquelleAutor Nic
  11. 0

    Pour VB aficionados:

    EnumStringValue = System.Enum.GetName(GetType(MyEnum), MyEnumValue)
    InformationsquelleAutor GlennG
  12. -1

    Simple: enum noms dans une Liste:

    List<String> NameList = Enum.GetNames(typeof(YourEnumName)).Cast<string>().ToList()
    • Salut @Brian, je ne pense pas que vous avez besoin de jeter la sortie de getnames a()
    InformationsquelleAutor Brian