Como seleciono um valor aleatório de uma enumeração?

Dada uma enumeração arbitrária em C #, como faço para selecionar um valor aleatório?

(Não encontrei esta pergunta muito básica no SO. Vou postar minha resposta em um minuto como referência para qualquer pessoa, mas fique à vontade para postar sua própria resposta.)

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

Use Enum.GetValues ​​para recuperar uma matriz de todos os valores. Em seguida, selecione um item de matriz aleatória.

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

Teste:

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

Você poderia fazer isso:

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

Não há necessidade de armazenar matrizes

Aqui está uma versão alternativa como uma Extension Methodutilização 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());
        }
    }           
}

Dois
um
quatro
quatro
quatro
três
dois
quatro
um
três

Chamada Enum.GetValues; isso retorna uma matriz que representa todos os valores possíveis para sua enumeração. Escolha um item aleatório dessa matriz. Lance esse item de volta ao tipo de enumeração original.

Aqui está uma função genérica para isso. Mantenha a criação do RNG fora do código de alta frequência.

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

Exemplo de uso:

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

Pessoalmente, sou fã de métodos de extensão, então usaria algo assim (embora não seja realmente uma extensão, é semelhante):

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 uma extensão de classe aleatória:

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

Exemplo de uso:

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

Você também pode converter um valor aleatório:

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

Mas você deve usar um randomizador melhor como o desta minha biblioteca .