Vous parcourez une énumération dans Silverlight?

Question

En .Net, il est possible de parcourir une énumération en utilisant

 System.Enum.GetNames(typeof(MyEnum))
 

ou

 System.Enum.GetValues(typeof(MyEnum))
 

Cependant, dans Silverlight 3, Enum.GetNames et Enum.GetValues ne sont pas définis. Est-ce que quelqu'un connaît une alternative?

Answer 1

Ou peut-être fortement typé avec 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();
    }
 

Answer 2

J'ai compris comment faire cela sans faire de suppositions sur l'énum, imitant les fonctions dans .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();
}
 

Answer 3

Je n'ai pas essayé cela, mais les API de réflexion devraient fonctionner.

Answer 4

Je crois que c'est la même chose que dans le .NET Compact Framework. Si nous supposons que vos valeurs enum commencent à 0 et utilisent chaque valeur jusqu'à ce que leur plage soit supérieure au code suivant, cela 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 pouvez modifier le code pour renvoyer les noms d’énumération ou pour faire correspondre différents modèles, par exemple des valeurs au niveau du bit.

Voici une autre version de la méthode qui renvoie 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;
}