public class NameValue
{
    public string Name { get; set; }
    public object Value { get; set; }
}

public class NameValue
{
    public string Name { get; set; }
    public object Value { get; set; }
}

public static List<NameValue> EnumToList<T>()
{
    var array = (T[])(Enum.GetValues(typeof(T)).Cast<T>()); 
    var array2 = Enum.GetNames(typeof(T)).ToArray<string>(); 
    List<NameValue> lst = null;
    for (int i = 0; i < array.Length; i++)
    {
        if (lst == null)
            lst = new List<NameValue>();
        string name = array2[i];
        T value = array[i];
        lst.Add(new NameValue { Name = name, Value = value });
    }
    return lst;
}

转换枚举到一个列表更多的信息可在这里。

简单的答案是，使用:

(SomeEnum[])Enum.GetValues(typeof(SomeEnum))

如果你需要一个局部变量，它是var allSomeEnumValues = (SomeEnum[])枚举. getvalues (typeof(SomeEnum));。

为什么语法是这样的?!

静态方法GetValues是在旧的。net 1.0时代引入的。它返回运行时类型SomeEnum[]的一维数组。但是因为它是非泛型方法(泛型直到。net 2.0才引入)，所以它不能这样声明它的返回类型(编译时返回类型)。

. net数组确实有一种协方差，但是因为SomeEnum将是一个值类型，并且因为数组类型协方差不适用于值类型，所以它们甚至不能将返回类型声明为对象[]或Enum[]。(这与。net 1.0中GetCustomAttributes的重载不同，后者具有编译时返回类型object[]，但实际上返回类型为SomeAttribute[]的数组，其中SomeAttribute必须是引用类型。)

因此，. net 1.0方法必须将其返回类型声明为System.Array。但我保证它是SomeEnum[]。

每次你用相同的枚举类型再次调用GetValues时，它将不得不分配一个新数组并将值复制到新数组中。这是因为数组可能会被方法的“消费者”写入(修改)，所以他们必须创建一个新的数组，以确保值是不变的。net 1.0没有好的只读集合。

如果你在很多不同的地方需要所有值的列表，考虑只调用一次GetValues并将结果缓存到只读包装器中，例如:

public static readonly ReadOnlyCollection<SomeEnum> AllSomeEnumValues
    = Array.AsReadOnly((SomeEnum[])Enum.GetValues(typeof(SomeEnum)));

然后可以多次使用AllSomeEnumValues，并且可以安全地重用相同的集合。

为什么使用.Cast<SomeEnum>()不好?

A lot of other answers use .Cast<SomeEnum>(). The problem with this is that it uses the non-generic IEnumerable implementation of the Array class. This should have involved boxing each of the values into an System.Object box, and then using the Cast<> method to unbox all those values again. Luckily the .Cast<> method seems to check the runtime type of its IEnumerable parameter (the this parameter) before it starts iterating through the collection, so it isn't that bad after all. It turns out .Cast<> lets the same array instance through.

如果后面跟着.ToArray()或.ToList()，如下所示:

Enum.GetValues(typeof(SomeEnum)).Cast<SomeEnum>().ToList() // DON'T do this

你有另一个问题:当你调用GetValues时，你创建了一个新的集合(数组)，然后用. tolist()调用创建一个新的集合(List<>)。因此，这是整个集合的一个(额外的)冗余分配来保存值。

更新:自。net 5.0(2020年起)起，上述信息已过时;最后还有一个泛型方法(泛型从2005年开始在。net Framework 2.0中引入)，所以现在你只需简单地使用:

Enum.GetValues<SomeEnum>()

其返回参数是强类型的(如SomeEnum[])。

List <SomeEnum> theList = Enum.GetValues(typeof(SomeEnum)).Cast<SomeEnum>().ToList();

Language[] result = (Language[])Enum.GetValues(typeof(Language))

你可以使用下面的泛型方法:

public static List<T> GetItemsList<T>(this int enums) where T : struct, IConvertible
{
    if (!typeof (T).IsEnum)
    {
        throw new Exception("Type given must be an Enum");
    }

    return (from int item in Enum.GetValues(typeof (T))
            where (enums & item) == item
            select (T) Enum.Parse(typeof (T), item.ToString(new CultureInfo("en")))).ToList();
}

更简单的方法:

Enum.GetValues(typeof(SomeEnum))
    .Cast<SomeEnum>()
    .Select(v => v.ToString())
    .ToList();