Come si seleziona un valore casuale da un'enumerazione?

Question

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

(non ho trovato questa domanda molto di base su SO. Vi posterò la mia risposta in un minuto come riferimento per chiunque, ma non esitate a inviare la propria risposta.)

Answer 1

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

Answer 2

Utilizzare Enum.GetValues ​​a recuperare una matrice di tutti i valori. Quindi seleziona un elemento dell'array casuale.

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

prova:

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 

---

Aggiornamento: Questa risposta originariamente utilizzato OrderBy (x => _Random.Next()).FirstOrDefault() per selezionare un elemento casuale. Usalo solo se sei irrazionalmente attratto dal mischiare con chiavi casuali. In ogni altro caso, usa invece la risposta accettata da Darin Dimitrov, che ho incorporato in questa risposta più tardi.

Answer 3

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

Answer 4

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

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

Usage:

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

Answer 5

Personalmente, io sono un fan di metodi di estensione, quindi vorrei usare qualcosa come questo (mentre in realtà 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); 
     } 
    } 

} 

Answer 6

Ecco una versione alternativa come Extension Method utilizzando 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

Answer 7

Si potrebbe semplicemente fare questo:

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

Non c'è bisogno di memorizzare le matrici