Come faccio a selezionare un valore casuale da un elenco?

Data un'enumerazione arbitraria in C #, come posso selezionare un valore casuale?

(Non ho trovato questa domanda basilare su SO. Pubblica la mia risposta tra un minuto come riferimento per chiunque, ma non esitate a pubblicare la vostra risposta.)

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

Utilizzare Enum.GetValues ​​per recuperare una matrice di tutti i valori. Quindi selezionare un oggetto array casuale.

static Random _R = new Random ();
static T RandomEnumValue<T> ()
{
    var v = Enum.GetValues (typeof (T));
    return (T) v.GetValue (_R.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

Potresti semplicemente fare questo:

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

Non è necessario archiviare array

Ecco una versione alternativa come Extension Methodutilizzo 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());
        }
    }           
}

Due
Uno
Quattro
Quattro
Quattro
Tre
Due
Quattro
Uno
Tre

Chiama Enum.GetValues; questo restituisce un array che rappresenta tutti i possibili valori per il tuo enum. Scegli un oggetto casuale da questo array. Riporta l'oggetto al tipo di enum originale.

Ecco una funzione generica per questo. Mantenere la creazione di RNG al di fuori del codice ad alta frequenza.

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

Esempio di utilizzo:

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

Personalmente, sono un fan dei metodi di estensione, quindi userei qualcosa di simile (anche se non è un'estensione, sembra simile):

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

}

Adattato come estensione di classe casuale:

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

Esempio di utilizzo:

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

Puoi anche lanciare un valore casuale:

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

Ma dovresti usare un randomizzatore migliore come quello in questa mia biblioteca .