/// <summary>
/// Method return a read-only collection of the names of the constants in specified enum
/// </summary>
/// <returns></returns>
public static ReadOnlyCollection<string> GetNames()
{
    return Enum.GetNames(typeof(T)).Cast<string>().ToList().AsReadOnly();   
}

其中T是枚举类型; 添加:

using System.Collections.ObjectModel; 

下面是我喜欢的使用LINQ的方式:

public class EnumModel
{
    public int Value { get; set; }
    public string Name { get; set; }
}

public enum MyEnum
{
    Name1=1,
    Name2=2,
    Name3=3
}

public class Test
{
        List<EnumModel> enums = ((MyEnum[])Enum.GetValues(typeof(MyEnum))).Select(c => new EnumModel() { Value = (int)c, Name = c.ToString() }).ToList();

        // A list of Names only, does away with the need of EnumModel 
        List<string> MyNames = ((MyEnum[])Enum.GetValues(typeof(MyEnum))).Select(c => c.ToString()).ToList();

        // A list of Values only, does away with the need of EnumModel 
        List<int> myValues = ((MyEnum[])Enum.GetValues(typeof(MyEnum))).Select(c => (int)c).ToList();

        // A dictionnary of <string,int>
        Dictionary<string,int> myDic = ((MyEnum[])Enum.GetValues(typeof(MyEnum))).ToDictionary(k => k.ToString(), v => (int)v);
}

希望能有所帮助

private List<SimpleLogType> GetLogType()
{
  List<SimpleLogType> logList = new List<SimpleLogType>();
  SimpleLogType internalLogType;
  foreach (var logtype in Enum.GetValues(typeof(Log)))
  {
    internalLogType = new SimpleLogType();
    internalLogType.Id = (int) (Log) Enum.Parse(typeof (Log), logtype.ToString(), true);
    internalLogType.Name = (Log)Enum.Parse(typeof(Log), logtype.ToString(), true);
    logList.Add(internalLogType);
  }
  return logList;
}

在top Code中，Log是一个枚举，SimpleLogType是一个日志结构。

public enum Log
{
  None = 0,
  Info = 1,
  Warning = 8,
  Error = 3
}

简单的答案是，使用:

(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[])。

非常简单的答案

下面是我在一个应用程序中使用的属性

public List<string> OperationModes
{
    get
    {
       return Enum.GetNames(typeof(SomeENUM)).ToList();
    }
}

我总是习惯于得到一个枚举值的列表，就像这样:

Array list = Enum.GetValues(typeof (SomeEnum));