Wie wähle ich einen zufälligen Wert aus einer Aufzählung aus?

Wie wähle ich bei einer beliebigen Aufzählung in C # einen zufälligen Wert aus?

(Ich habe diese sehr grundlegende Frage auf SO nicht gefunden. Ich werde meine Antwort in einer Minute als Referenz für jeden veröffentlichen, aber Sie können gerne Ihre eigene Antwort veröffentlichen.)

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

Verwenden Sie Enum.GetValues, um ein Array aller Werte abzurufen. Wählen Sie dann ein zufälliges Array-Element aus.

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

Prüfung:

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

Sie könnten dies einfach tun:

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

Arrays müssen nicht gespeichert werden

Hier ist eine alternative Version als Extension MethodVerwendung 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());
        }
    }           
}

Zwei
Eins
Vier
Vier
Vier
Drei
Zwei
Vier Vier
Eins
Drei

Rufen Sie an Enum.GetValues; Dies gibt ein Array zurück, das alle möglichen Werte für Ihre Aufzählung darstellt. Wählen Sie ein zufälliges Element aus diesem Array. Wirf diesen Gegenstand auf den ursprünglichen Aufzählungstyp zurück.

Hier ist eine generische Funktion dafür. Halten Sie die RNG-Erstellung außerhalb des Hochfrequenzcodes.

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

Anwendungsbeispiel:

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

Persönlich bin ich ein Fan von Erweiterungsmethoden, daher würde ich so etwas verwenden (obwohl es nicht wirklich eine Erweiterung ist, sieht es ähnlich aus):

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

}

Angepasst als zufällige Klassenerweiterung:

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

Anwendungsbeispiel:

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

Sie können auch einen zufälligen Wert umwandeln:

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

Aber Sie sollten einen besseren Randomizer wie den in meiner Bibliothek verwenden .