使用Enum.GetValues检索所有值的数组。然后选择一个随机数组项目。

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

测试：

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

调用 Enum.GetValues ；这将返回一个表示枚举的所有可能值的数组。从该数组中随机选取一项。将该项转换回原始枚举类型。

下面是它的一个通用函数。将RNG创建放在高频代码之外。

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

使用示例：

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

就我个人而言，我是扩展方法的粉丝，所以我会使用这样的方法(虽然不是真正的扩展，但它看起来很相似)：

public enum Options {
    Zero,
    Three,
    Four,
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);
}

你可以这样做：

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

不需要存储数组

改编为随机类扩展：

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

用法示例：

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

这些答案中的许多都是相当古老的-如果我错了请纠正我-似乎使用了一些粗略的概念，如类型擦除和动态类型转换。然而，正如用户Yarek T指出的那样， generic overload of Enum.GetValues 不需要这样做

static Random random = new Random();
// Somewhat unintuitively, we need to constrain the type parameter to
// both struct *and* Enum - struct is required b/c the type can't be
// nullable, and Enum is required b/c GetValues expects an Enum type.
// You'd think that Enum itself would satisfy the non-nullable
// constraint, but alas, me compiler tells me otherwise - perhaps
// someone more knowledgeable can explain why this is in a comment?
static TEnum RandomEnumValue<TEnum>() where TEnum : struct, Enum
    TEnum[] vals = Enum.GetValues<TEnum>();
    return vals[random.Next(vals.Length)];
}

或者，就像在 borja garcia's answer 中一样，我们甚至可以将其编写为随机类的扩展

public static class RandomExtensions
    public static TEnum NextEnumValue<TEnum>(this Random random)
        where TEnum : struct, Enum
        TEnum[] vals = Enum.GetValues<TEnum>();
        return vals[random.Next(vals.Length)];
}

我们可以从 mafu's answer 运行相同的测试

Random random = new Random();
for (int i = 0; i < 10; i++) {
    var day = random.NextEnumValue<System.DayOfWeek>();
    Console.WriteLine(day.ToString());
}

潜在输出：

Thursday
Saturday
Sunday
Sunday
Sunday
Saturday
Wednesday
Monday
Wednesday
Thursday

结合 this answer 和 its comment 的现代解决方案

public static class RandomExtensions
    private static Random Random = new Random();