Comment sélectionner une valeur aléatoire à partir d'une énumération?

Question

Étant donné une énumération arbitraire en C#, comment puis-je sélectionner une valeur aléatoire?

(je ne trouve pas cette question fondamentale sur le SO. Je vais poster ma réponse dans une minute comme référence pour personne, mais s'il vous plaît ne hésitez pas à poster votre propre réponse.)

Answer 1

Array values = Enum.GetValues(typeof(Bar)); 
Random random = new Random(); 
Bar randomBar = (Bar)values.GetValue(random.Next(values.Length)); 

Answer 2

Utilisez Enum.GetValues ​​à récupérer un tableau de toutes les valeurs. Ensuite, sélectionnez un élément de tableau aléatoire.

static T RandomEnumValue<T>() 
{ 
    var v = Enum.GetValues (typeof (T)); 
    return (T) v.GetValue (new Random().Next(v.Length)); 
} 

Test:

for (int i = 0; i < 10; i++) { 
    var value = RandomEnumValue<System.DayOfWeek>(); 
    Console.WriteLine (value.ToString()); 
} 

->

Tuesday 
Saturday 
Wednesday 
Monday 
Friday 
Saturday 
Saturday 
Saturday 
Friday 
Wednesday 

---

Mise à jour: Cette réponse utilisée à l'origine OrderBy (x => _Random.Next()).FirstOrDefault() pour sélectionner un élément aléatoire. Ne l'utilisez que si vous êtes irrationnellement attiré par des touches aléatoires. Dans tous les autres cas, utilisez plutôt la réponse acceptée par Darin Dimitrov, que j'ai incorporée dans cette réponse plus tard.

Answer 3

Appelez Enum.GetValues; cela retourne un tableau qui représente toutes les valeurs possibles pour votre énumération. Choisissez un objet aléatoire dans ce tableau. Convertir cet élément en retour au type enum d'origine.

Answer 4

Voici une fonction générique pour cela. Conserver la création RNG en dehors du code haute fréquence.

public static Random RNG = new Random(); 

public static T RandomEnum<T>() 
{ 
    Type type = typeof(T); 
    Array values = Enum.GetValues(type); 
    lock(RNG) 
    { 
     object value= values.GetValue(RNG.Next(values.Length)); 
     return (T)Convert.ChangeType(value, type); 
    } 
} 

Exemple d'utilisation:

System.Windows.Forms.Keys randomKey = RandomEnum<System.Windows.Forms.Keys>(); 

Answer 5

Personnellement, je suis fan des méthodes d'extension, donc j'utiliser quelque chose comme ça (alors pas vraiment une extension, il ressemble):

public enum Options { 
    Zero, 
    One, 
    Two, 
    Three, 
    Four, 
    Five 
} 

public static class RandomEnum { 
    private static Random _Random = new Random(Environment.TickCount); 

    public static T Of<T>() { 
     if (!typeof(T).IsEnum) 
      throw new InvalidOperationException("Must use Enum type"); 

     Array enumValues = Enum.GetValues(typeof(T)); 
     return (T)enumValues.GetValue(_Random.Next(enumValues.Length)); 
    } 
} 

[TestClass] 
public class RandomTests { 
    [TestMethod] 
    public void TestMethod1() { 
     Options option; 
     for (int i = 0; i < 10; ++i) { 
      option = RandomEnum.Of<Options>(); 
      Console.WriteLine(option); 
     } 
    } 

} 

Answer 6

Voici une autre version en tant que Extension Method en utilisant LINQ.

using System; 
using System.Linq; 

public static class EnumExtensions 
{ 
    public static Enum GetRandomEnumValue(this Type t) 
    { 
     return Enum.GetValues(t)   // get values from Type provided 
      .OfType<Enum>()    // casts to Enum 
      .OrderBy(e => Guid.NewGuid()) // mess with order of results 
      .FirstOrDefault();   // take first item in result 
    } 
} 

public static class Program 
{ 
    public enum SomeEnum 
    { 
     One = 1, 
     Two = 2, 
     Three = 3, 
     Four = 4 
    } 

    public static void Main() 
    { 
     for(int i=0; i < 10; i++) 
     { 
      Console.WriteLine(typeof(SomeEnum).GetRandomEnumValue()); 
     } 
    }   
} 

Deux
Un
Quatre
Quatre
Quatre
Trois
Deux
Quatre
Un
Trois

Answer 7

Vous pouvez simplement faire ceci:

var rnd = new Random(); 
return (MyEnum) rnd.Next(Enum.GetNames(typeof(MyEnum)).Length); 

Pas besoin de stocker des tableaux