我知道这有点乱，但如果你喜欢一句话，这里有一句：

((Suit[])Enum.GetValues(typeof(Suit))).ToList().ForEach(i => DoSomething(i));

我的解决方案在.NET Compact Framework（3.5）中工作，并支持编译时的类型检查：

public static List<T> GetEnumValues<T>() where T : new() {
    T valueType = new T();
    return typeof(T).GetFields()
        .Select(fieldInfo => (T)fieldInfo.GetValue(valueType))
        .Distinct()
        .ToList();
}

public static List<String> GetEnumNames<T>() {
    return typeof (T).GetFields()
        .Select(info => info.Name)
        .Distinct()
        .ToList();
}

如果有人知道如何去掉T valueType=new T（），我很乐意看到一个解决方案。

通话内容如下：

List<MyEnum> result = Utils.GetEnumValues<MyEnum>();

如果您知道类型将是枚举，但在编译时不知道确切的类型是什么，该怎么办？

public class EnumHelper
{
    public static IEnumerable<T> GetValues<T>()
    {
        return Enum.GetValues(typeof(T)).Cast<T>();
    }

    public static IEnumerable getListOfEnum(Type type)
    {
        MethodInfo getValuesMethod = typeof(EnumHelper).GetMethod("GetValues").MakeGenericMethod(type);
        return (IEnumerable)getValuesMethod.Invoke(null, null);
    }
}

getListOfEnum方法使用反射获取任何枚举类型，并返回所有枚举值的IEnumerable。

用法：

Type myType = someEnumValue.GetType();

IEnumerable resultEnumerable = getListOfEnum(myType);

foreach (var item in resultEnumerable)
{
    Console.WriteLine(String.Format("Item: {0} Value: {1}",item.ToString(),(int)item));
}

我不认为这更好，甚至更好。我只是在陈述另一种解决方案。

如果枚举值的范围严格从0到n-1，则通用替代方法是：

public void EnumerateEnum<T>()
{
    int length = Enum.GetValues(typeof(T)).Length;
    for (var i = 0; i < length; i++)
    {
        var @enum = (T)(object)i;
    }
}

如果枚举值是连续的，并且可以提供枚举的第一个和最后一个元素，则：

public void EnumerateEnum()
{
    for (var i = Suit.Spade; i <= Suit.Diamond; i++)
    {
        var @enum = i;
    }
}

但这不是严格的枚举，只是循环。第二种方法比任何其他方法都快得多。。。

foreach (Suit suit in Enum.GetValues(typeof(Suit)))
{
}

（目前公认的答案有一个我不认为的演员阵容需要（尽管我可能错了）。）

三种方式：

Enum.GetValues（类型）//自.NET 1.1起，不在Silverlight或.NET Compact Framework中type.GetEnumValues（）//仅适用于.NET 4及更高版本type.GetFields（）。其中（x=>x.IsLiteral）。Select（x=>x.GetValue（null））//在任何地方都有效

我不确定为什么在类型实例上引入GetEnumValues。对我来说，它一点也不可读。

拥有Enum＜T＞这样的助手类对我来说是最可读和难忘的：

public static class Enum<T> where T : struct, IComparable, IFormattable, IConvertible
{
    public static IEnumerable<T> GetValues()
    {
        return (T[])Enum.GetValues(typeof(T));
    }

    public static IEnumerable<string> GetNames()
    {
        return Enum.GetNames(typeof(T));
    }
}

现在您拨打：

Enum<Suit>.GetValues();

// Or
Enum.GetValues(typeof(Suit)); // Pretty consistent style

如果性能很重要，也可以使用某种缓存，但我不认为这是一个问题。

public static class Enum<T> where T : struct, IComparable, IFormattable, IConvertible
{
    // Lazily loaded
    static T[] values;
    static string[] names;

    public static IEnumerable<T> GetValues()
    {
        return values ?? (values = (T[])Enum.GetValues(typeof(T)));
    }

    public static IEnumerable<string> GetNames()
    {
        return names ?? (names = Enum.GetNames(typeof(T)));
    }
}