Comment sélectionner une valeur aléatoire dans une énumération?

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

(Je n'ai pas trouvé cette question très basique sur SO. Je publierai ma réponse dans une minute comme référence pour tout le monde, mais n'hésitez pas à poster votre propre réponse.)

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

Utilisez Enum.GetValues ​​pour récupérer un tableau de toutes les valeurs. Sélectionnez ensuite un élément de tableau aléatoire.

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

Tester:

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

Vous pouvez simplement faire ceci:

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

Pas besoin de stocker des tableaux

Voici une version alternative comme Extension Methodutilisation 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

Appel Enum.GetValues; cela renvoie un tableau qui représente toutes les valeurs possibles pour votre énumération. Choisissez un élément au hasard dans ce tableau. Cast cet élément vers le type d'énumération d'origine.

Voici une fonction générique pour cela. Gardez 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>();

Personnellement, je suis un fan des méthodes d'extension, donc j'utiliserais quelque chose comme ça (bien que ce ne soit pas vraiment une extension, cela a l'air similaire):

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);
        }
    }

}

Adapté comme une extension de classe aléatoire:

public static class RandomExtensions
{   
    public static T NextEnum<T>(this Random random)
    {
        var values = Enum.GetValues(typeof(T));
        return (T)values.GetValue(random.Next(values.Length));
    }
}

Exemple d'utilisation:

var random = new Random();
var myEnumRandom = random.NextEnum<MyEnum>();

Vous pouvez également lancer une valeur aléatoire:

using System;

enum Test {
  Value1,
  Value2,
  Value3
}

class Program {
  public static void Main (string[] args) {
    var max = Enum.GetValues(typeof(Test)).Length;
    var value = (Test)new Random().Next(0, max - 1);
    Console.WriteLine(value);
  }
}

Mais vous devriez utiliser un meilleur randomiseur comme celui de cette bibliothèque .