Une itération à travers une énumération dans Silverlight?

Dans .Net, il est possible d'itérer à travers une énumération en utilisant 

System.Enum.GetNames(typeof(MyEnum))

ou 

System.Enum.GetValues(typeof(MyEnum))

Dans Silverlight 3 toutefois, le protocole Enum.Getnames a et Enum.GetValues ne sont pas définis. Quelqu'un sait-il une alternative?

  • C'est ridicule que ce n'est pas dans le cadre. La taille du téléchargement est pas une excuse à la torture, les devs.
  • si quelqu'un a besoin, plus précisément, GetEnumValues() et GetEnumNames(); j'ai mis en œuvre (en fonction de la réponse par ptoinson et Shimmy ci-dessous) comme une réponse à la question suivante: stackoverflow.com/questions/7062208/... , et je pense qu'ils sont l'équivalent de l'ordinaire (mais non Silverlight) .NET des fonctions du même nom.
InformationsquelleAutor eriksmith200 | 2009-06-24
  1. 30

    Ou peut-être fortement typés à l'aide de linq, comme ceci:

        public static T[] GetEnumValues<T>()
    {
        var type = typeof(T);
        if (!type.IsEnum)
            throw new ArgumentException("Type '" + type.Name + "' is not an enum");

        return (
          from field in type.GetFields(BindingFlags.Public | BindingFlags.Static)
          where field.IsLiteral
          select (T)field.GetValue(null)
        ).ToArray();
    }

    public static string[] GetEnumStrings<T>()
    {
        var type = typeof(T);
        if (!type.IsEnum)
            throw new ArgumentException("Type '" + type.Name + "' is not an enum");

        return (
          from field in type.GetFields(BindingFlags.Public | BindingFlags.Static)
          where field.IsLiteral
          select field.Name
        ).ToArray();
    }
    • Mieux vaut mettre where T : struct,IConvertible dans la définition de la méthode pour se rapprocher de restreindre T pour les énumérations seulement.
    InformationsquelleAutor ptoinson
  2. 27

    J'ai trouvé comment faire cela sans faire d'hypothèses sur les enum, imitant les fonctions dans les .Net:

    public static string[] GetNames(this Enum e) {
    List<string> enumNames = new List<string>();

    foreach (FieldInfo fi in e.GetType().GetFields(BindingFlags.Static | BindingFlags.Public)){
        enumNames.Add(fi.Name);
    }

    return enumNames.ToArray<string>();
}

public static Array GetValues(this Enum e) {
    List<int> enumValues = new List<int>();

    foreach (FieldInfo fi in e.GetType().GetFields(BindingFlags.Static | BindingFlags.Public)) {
        enumValues.Add((int)Enum.Parse(e.GetType(), fi.Name, false));
    }

    return enumValues.ToArray();
}
    • Bonne solution +1!
    • Je voudrais cependant vous suggérons un IList<string> pour le sommet de la méthode, et IList<int> pour le second. Et n'oubliez pas que ce ne prendra pas en charge les énumérations, qui représentent une valeur de type long.
    • Vous pourriez supporter les non-int types en obtenant le type sous-jacent (Enum.GetUnderlyingType())
    • Cette solution laisse un peu à désirer. La syntaxe d'utilisation il vous suffit de fournir une instance de type énumération, alors que l'original .net méthodes vous permettent de travailler sur le type de directement. À cet égard, je trouve la réponse de @ptoinson mieux. Sa syntaxe est simple et propre. GetEnumValues<MyEnumType>()
    InformationsquelleAutor eriksmith200
  3. 3

    Je n'ai pas essayé, mais la réflexion Api devrait fonctionner.

    InformationsquelleAutor John Fisher
  4. 1

    Je trouve que c'est le même que dans le .NET Compact Framework. Si nous faisons l'hypothèse que vos valeurs enum commencent à 0 et utiliser toutes les valeurs jusqu'à ce que leur portée est plus le code suivant devrait fonctionner.

    public static IList<int> GetEnumValues(Type oEnumType)
{
  int iLoop = 0;
  bool bDefined = true;
  List<int> oList = new List<int>();

  //Loop values
  do
  {
    //Check if the value is defined
    if (Enum.IsDefined(oEnumType, iLoop))
    {
      //Add item to the value list and increment
      oList.Add(iLoop);
      ++iLoop;
    }
    else
    {
      //Set undefined
      bDefined = false;
    }
  } while (bDefined);

  //Return the list
  return oList;
}

    Évidemment, vous pourriez modifier le code de retour de l'énumération des noms ou pour s'adapter à différents modèles par exemple au niveau du bit valeurs.

    Voici une autre version de la méthode qui retourne un IList<EnumType>.

    public static IList<T> GetEnumValues<T>()
{
  Type oEnumType;
  int iLoop = 0;  
  bool bDefined = true;  
  List<T> oList = new List<T>();  

  //Get the enum type
  oEnumType = typeof(T);

  //Check that we have an enum
  if (oEnumType.IsEnum)
  {
    //Loop values  
    do
    {
      //Check if the value is defined    
      if (Enum.IsDefined(oEnumType, iLoop))
      {
        //Add item to the value list and increment      
        oList.Add((T) (object) iLoop);
        ++iLoop;
      }
      else
      {
        //Set undefined      
        bDefined = false;
      }
    } while (bDefined);
  }

  //Return the list  
  return oList;
}
    • Je sais que vous avez eu l'inconvénient de supposer que contiguë valeurs, mais en particulier de toute [Drapeaux] attribué les énumérations ne fonctionnerait pas.
    • Lire la dernière sentance, je l'ai reconnue que vous pourriez utiliser un modèle différent pour correspondre au niveau du bit valeurs par exemple [Drapeaux]; pour ce faire, ++iLoop; devient iLoop = iLoop << 1;.
    • Une demande si vous n'avez pas l'esprit: puisque ce n'est pas revenir à un certain nombre de types énumérés, mais plutôt une List<int>, il ne fait pas correspondre au comportement sur l' .NET plate-forme, et a provoqué un bon peu de confusion pour moi, lorsque vous essayez de déterminer si cette fonction serait de travailler pour un autre utilisateur. Seriez-vous ouvert à renommer en quelque chose d'autre? Le problème principal pour moi était que GetArrayValues(i).ToString() renvoie une chaîne de le nombre, plutôt que de l'enum nom, comme c'est renvoyé par le réel .Version NET, même si je suis sûr qu'il y a d'autres sources possibles de confusion.
    • Pourquoi ne pas utiliser ((EnumType)GetArrayValues[i]).ToString() ou dans VB.NET CType(GetArrayValues(i), EnumType).ToString()? Ma réponse stipule que le code ci-dessus est juste un exemple simple et peut facilement être ré-écrit pour le retour d'un autre type ou d'un match, un autre enum modèle.
    • Parce que dans la interlocuteur, le EnumType était pas connu à l'avance; seulement, disons, Type CurrentEnumType; a été donné. Et je suis d'accord que vous avez suffisamment précisé dans la suite du texte, c'est juste que c'était une source de confusion pour moi (qui n'était pas familier avec la valeur de retour; un Tableau contenant quels que soient les types enum sont) parce que j'avais supposé que le fait d'avoir le même nom signifiait qu'il a renvoyé la même chose que la norme .NET framework méthode.
    • La méthode est très simple et il est clair pour voir de quel type est retourné. Pour l'amour d'un couple de minutes, je vais poster une autre signature qui sera de retour IList<EnumType>.
    • Je ne remets pas que le type de retour est clair, la seule chose qui n'est pas évident pour quelqu'un qui n'a pas de familiarité avec le .NET appel, c'est que cette fonction n'a pas le même comportement que le cadre. Pas tout le monde est familier avec cette méthode. J'ai vu un nom identique méthode et supposé qu'il permettrait de répondre au besoin de quelqu'un pour elle. Donc, j'ai pensé qu'il était raisonnable de vous demander de ne pas quitter une fonction qui a un mauvais signature et qui donc peuvent aller à l'encontre d'un utilisateur d'attente.
    • Aussi, si vous êtes de retour IList<EnumType> avec le même nom, vous aurez toujours trompeur le nom de la fonction, ne correspond pas à la .NET framework fonction qui retourne un Tableau. Au minimum, le code appelant .Longueur devra être modifiée .Le comte, je pense donc qu'il est également raisonnable si cette fonction ne pas être nommé GetEnumValues. Si vous vous sentez très fortement à ce sujet d'être nommé GetEnumValues, je ne vais pas continuer à discuter sur ce point.
    • J'ai essayé d'être utile, mais cela n'a pas fonctionné donc, voici les faits. Ma méthode n'a pas la même signature que la méthode du cadre MyClass.GetEnumValues vs Enum.GetValues. Il n'y a rien sur cette méthode que les sauts de lignes directrices de codage. Je ne vois vraiment pas comment un programmeur peut être confondu par ce que vous pouvez lire le code source. Plus important encore, si vous ne l'aimez pas, alors ne l'utilisez pas!
    • Le nom de la collision a causé les problèmes quand j'ai essayé d'aider quelqu'un, pour les raisons décrites dans trois de plus en plus des commentaires détaillés ci-dessus. J'ai fait une demande raisonnable, ce qui vous n'avez jamais directement répondu, et puis tout simplement essayé de vous faire comprendre ce qui s'était réellement passée. Je n'ai rien dit des "directives de codage" et ce que j'ai dit était poli, et est là pour tout le monde, y compris vous. Un simple "Non" de vous à tout moment, aurait suffi. De plus j'ai eu juste dit que je ne voudrais pas continuer si vous vous êtes senti fortement sur le nom! J'ai donc vraiment n'obtenez pas le besoin pour le dernier commentaire. w/e
    • Il n'y a PAS de nommage de collision!
    • Désolé, le métaphorique nom de collision, @Steveo3000. w/e, j'ai dit tout ce que je soin de dire à ce sujet. Bien que, apparemment, vous avez de ne pas prendre le temps d'écouter la réponse à votre première question: que nous n'avions qu'un " Type CurrentEnumType;' variable de travailler avec, pas connu EnumType. Mais vous avez donné une fonction prenant un modèle de param, qui ne peut même pas être rempli avec un Type de variable. N'a pas d'importance, il était inutile de toute façon, avait déjà modifié une autre réponse à l'identique du .NET framework est Enum.GetEnumValues appel, sans aucune restriction sur la valeur. Mais vous semblez avoir manqué beaucoup de ce que j'ai dit.

    InformationsquelleAutor stevehipwell