¿Cómo selecciono un valor aleatorio de una enumeración?

Dada una enumeración arbitraria en C #, ¿cómo selecciono un valor aleatorio?

(No encontré esta pregunta muy básica sobre SO. Publicaré mi respuesta en un minuto como referencia para cualquiera, pero no dude en publicar su propia respuesta).

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

Use Enum.GetValues ​​para recuperar una matriz de todos los valores. Luego seleccione un elemento de matriz aleatorio.

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

Prueba:

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

Podrías hacer esto:

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

No es necesario almacenar matrices

Aquí hay una versión alternativa como un Extension Methoduso 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());
        }
    }           
}

Dos
Uno
Cuatro
Cuatro
Cuatro
Tres
Dos
Cuatro
Uno
Tres

Llamada Enum.GetValues; esto devuelve una matriz que representa todos los valores posibles para su enumeración. Elija un elemento aleatorio de esta matriz. Devuelve ese elemento al tipo de enumeración original.

Aquí hay una función genérica para ello. Mantenga la creación de RNG fuera del código de alta frecuencia.

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

Ejemplo de uso:

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

Personalmente, soy un fanático de los métodos de extensión, por lo que usaría algo como esto (aunque en realidad no es una extensión, se ve similar):

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

}

Adaptado como una extensión de clase aleatoria:

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

Ejemplo de uso:

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

También puede emitir un valor aleatorio:

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

Pero deberías usar un mejor aleatorizador como el de esta biblioteca mía.