如何枚举枚举


3763

您如何枚举enumC#?

例如,以下代码无法编译:

public enum Suit
{
    Spades,
    Hearts,
    Clubs,
    Diamonds
}

public void EnumerateAllSuitsDemoMethod()
{
    foreach (Suit suit in Suit)
    {
        DoSomething(suit);
    }
}

并且它给出了以下编译时错误:

“西装”是“类型”,但像“变量”一样使用

Suit关键字第二个失败。



2
您可能想看看C#枚举的来龙去脉,它讨论了此以及其他有用的枚举花絮
ChaseMedallion

Answers:


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

注意:强制转换(Suit[])不是严格必需的,但是它确实使代码快了0.5 ns


97
如果枚举数列表中有重复的值,则此方法不起作用。
杰西(Jessy)2012年

10
我只想指出,不幸的是,这在Silverlight中不起作用,因为silverlight库不包含enum.GetValues。在这种情况下,您必须使用反射。
Giacomo Tagliabue

146
@Jessy 确实在出现类似情况时有效enum E {A = 0, B = 0}Enum.GetValues导致返回两个值,尽管它们是相同的。E.A == E.B是真的,所以没有区别。如果要使用个人名称,则应查找Enum.GetNames
2013年

13
然后,如果枚举中有重复项/同义词,并且您想要其他行为,则可以使用Linq的Distinct扩展名(自.NET 3.5起),因此foreach (var suit in ((Suit[])Enum.GetValues(typeof(Suit))).Distinct()) { }
Jeppe Stig Nielsen 2014年

42
我犯了尝试var用于该类型的错误。编译器将变量Object设为an 而不是枚举。明确列出枚举类型。
jpmc26 2016年

695

在我看来,您确实想要打印出每个枚举的名称,而不是值。在这种情况下,Enum.GetNames()似乎是正确的方法。

public enum Suits
{
    Spades,
    Hearts,
    Clubs,
    Diamonds,
    NumSuits
}

public void PrintAllSuits()
{
    foreach (string name in Enum.GetNames(typeof(Suits)))
    {
        System.Console.WriteLine(name);
    }
}

顺便说一句,增加值不是枚举枚举值的好方法。您应该这样做。

我会Enum.GetValues(typeof(Suit))改用。

public enum Suits
{
    Spades,
    Hearts,
    Clubs,
    Diamonds,
    NumSuits
}

public void PrintAllSuits()
{
    foreach (var suit in Enum.GetValues(typeof(Suits)))
    {
        System.Console.WriteLine(suit.ToString());
    }
}

2
VB语法在这里: 链接
AndruWitta

我把你的版本从我身边一个小以下变化:Enum.GetValues(typeof(Suits)).OfType<Suits>().ToArray()。在那种情况下,我可以迭代Suits枚举项数组,而不是字符串。
Barabas

@Barabas为什么不只是做Suits suit in Enum.GetValues(typeof(Suits))
themadking

@themadking哦,伙计!当然,使用完全型看起来比这个可怕的一段SH ...代码!
巴拉巴斯

337

我做了一些扩展,以方便枚举使用。也许有人可以使用它...

public static class EnumExtensions
{
    /// <summary>
    /// Gets all items for an enum value.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="value">The value.</param>
    /// <returns></returns>
    public static IEnumerable<T> GetAllItems<T>(this Enum value)
    {
        foreach (object item in Enum.GetValues(typeof(T)))
        {
            yield return (T)item;
        }
    }

    /// <summary>
    /// Gets all items for an enum type.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="value">The value.</param>
    /// <returns></returns>
    public static IEnumerable<T> GetAllItems<T>() where T : struct
    {
        foreach (object item in Enum.GetValues(typeof(T)))
        {
            yield return (T)item;
        }
    }

    /// <summary>
    /// Gets all combined items from an enum value.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="value">The value.</param>
    /// <returns></returns>
    /// <example>
    /// Displays ValueA and ValueB.
    /// <code>
    /// EnumExample dummy = EnumExample.Combi;
    /// foreach (var item in dummy.GetAllSelectedItems<EnumExample>())
    /// {
    ///    Console.WriteLine(item);
    /// }
    /// </code>
    /// </example>
    public static IEnumerable<T> GetAllSelectedItems<T>(this Enum value)
    {
        int valueAsInt = Convert.ToInt32(value, CultureInfo.InvariantCulture);

        foreach (object item in Enum.GetValues(typeof(T)))
        {
            int itemAsInt = Convert.ToInt32(item, CultureInfo.InvariantCulture);

            if (itemAsInt == (valueAsInt & itemAsInt))
            {
                yield return (T)item;
            }
        }
    }

    /// <summary>
    /// Determines whether the enum value contains a specific value.
    /// </summary>
    /// <param name="value">The value.</param>
    /// <param name="request">The request.</param>
    /// <returns>
    ///     <c>true</c> if value contains the specified value; otherwise, <c>false</c>.
    /// </returns>
    /// <example>
    /// <code>
    /// EnumExample dummy = EnumExample.Combi;
    /// if (dummy.Contains<EnumExample>(EnumExample.ValueA))
    /// {
    ///     Console.WriteLine("dummy contains EnumExample.ValueA");
    /// }
    /// </code>
    /// </example>
    public static bool Contains<T>(this Enum value, T request)
    {
        int valueAsInt = Convert.ToInt32(value, CultureInfo.InvariantCulture);
        int requestAsInt = Convert.ToInt32(request, CultureInfo.InvariantCulture);

        if (requestAsInt == (valueAsInt & requestAsInt))
        {
            return true;
        }

        return false;
    }
}

枚举本身必须用FlagsAttribute装饰:

[Flags]
public enum EnumExample
{
    ValueA = 1,
    ValueB = 2,
    ValueC = 4,
    ValueD = 8,
    Combi = ValueA | ValueB
}

13
一种用于第一种扩展方法的衬管;不再懒惰。返回Enum.GetValues(typeof(T))。Cast <T>();
Leyu 2010年

2
另外,您也可以使用OfType:Enum.GetValues(typeof(T))。OfType <T>()。太糟糕了,没有GetValues <T>()的通用版本,那么它将更加精致。
jpierson 2011年

3
也许有人可以展示如何使用这些扩展?编译器未在枚举EnumExample中显示扩展方法。
Tomas

1
谁能举例说明如何利用这些功能?
Ashwini Verma 2013年

3
+1表示可重用的代码:示例-将这些扩展方法保存在库中,并对其进行引用。List <string> myTypeNames = mytypes.GetAllItems();
克里希纳

178

.NET框架的某些版本不支持Enum.GetValues。这是Ideas 2.0的一个很好的解决方法:Compact Framework中的Enum.GetValues

public Enum[] GetValues(Enum enumeration)
{
    FieldInfo[] fields = enumeration.GetType().GetFields(BindingFlags.Static | BindingFlags.Public);
    Enum[] enumerations = new Enum[fields.Length];

    for (var i = 0; i < fields.Length; i++)
        enumerations[i] = (Enum) fields[i].GetValue(enumeration);

    return enumerations;
}

与任何涉及反射的代码一样,您应采取步骤确保其仅运行一次并缓存结果。


18
为什么不在此处使用yield关键字来实例化列表呢?
埃里克·米克尔森

1
或更短的时间:return type.GetFields().Where(x => x.IsLiteral).Select(x => x.GetValue(null)).Cast<Enum>();
nawfal

7
@nawfal:Linq无法使用.Net CF 2.0。
加百利通用汽车公司

@Ekevoo如何将此枚举值绑定到MVC中的DropDownList?
杰克

115

用途Cast<T>

var suits = Enum.GetValues(typeof(Suit)).Cast<Suit>();

你去那里IEnumerable<Suit>


1
这在from子句和foreach标头声明符中也有效。
Aluan Haddad

97

我认为这比其他建议更有效,因为GetValues()每次循环时都不会调用它。它也更加简洁。并且您得到一个编译时错误,如果Suit不是,则不会出现运行时异常enum

EnumLoop<Suit>.ForEach((suit) => {
    DoSomethingWith(suit);
});

EnumLoop 具有以下完全通用的定义:

class EnumLoop<Key> where Key : struct, IConvertible {
    static readonly Key[] arr = (Key[])Enum.GetValues(typeof(Key));
    static internal void ForEach(Action<Key> act) {
        for (int i = 0; i < arr.Length; i++) {
            act(arr[i]);
        }
    }
}

6
谨慎使用此类泛型。如果您尝试使用EnumLoop不是枚举的某种类型,它将很好地编译,但在运行时会引发异常。
svick

7
谢谢你,斯威克。该页面上的其他答案实际上会发生运行时异常……除了这一点外,因为我添加了“ where Key:struct,IConvertible”,因此在大多数情况下会出现编译时错误。
詹姆斯

3
不,GetValues()在foreach中仅被调用一次。
亚历克斯·布洛卡

4
詹姆斯,我不鼓励您上课,因为聪明的人写的很好,但是在许多人会维护和更新的生产代码中,聪明的人是额外的工作。如果它能节省很多钱或会被大量使用-这样可以节省很多钱并且人们会逐渐熟悉它-这是值得的,但是在大多数情况下,它会使人们尝试阅读和更新代码的速度变慢,并可能引入将来会发现错误。更少的代码更好:)更少的复杂性甚至更好。
Grant M

2
@GrantM为什么?该代码既不复杂,又非常短。最重要的是,根据他的示例,编写一次该类将允许使用进行更短的代码迭代。这非常干净,如果您无法更新该代码,则可能无法更新任何公司代码。
Dispersia

77

你不会得到Enum.GetValues()Silverlight中

Einar Ingebrigtsen撰写的原始博客文章

public class EnumHelper
{
    public static T[] GetValues<T>()
    {
        Type enumType = typeof(T);

        if (!enumType.IsEnum)
        {
            throw new ArgumentException("Type '" + enumType.Name + "' is not an enum");
        }

        List<T> values = new List<T>();

        var fields = from field in enumType.GetFields()
                     where field.IsLiteral
                     select field;

        foreach (FieldInfo field in fields)
        {
            object value = field.GetValue(enumType);
            values.Add((T)value);
        }

        return values.ToArray();
    }

    public static object[] GetValues(Type enumType)
    {
        if (!enumType.IsEnum)
        {
            throw new ArgumentException("Type '" + enumType.Name + "' is not an enum");
        }

        List<object> values = new List<object>();

        var fields = from field in enumType.GetFields()
                     where field.IsLiteral
                     select field;

        foreach (FieldInfo field in fields)
        {
            object value = field.GetValue(enumType);
            values.Add(value);
        }

        return values.ToArray();
    }
}

2
不错的解决方案,但有些重构会更好!:)
nawfal

我正在使用.NET Framework 4.0和silverlight enum.getvalues工作,我使用的代码是---> enum.GetValues(typeof(enum))
Ananda

2
从C#7.3(Visual Studio 2017≥v15.7)开始,可以使用where T: Enum
Yahoo严重

59

我的解决方案在.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>();

2
那使用T valueType = default(T)呢?
奥利弗2010年

太好了,我什至都不知道那个关键字。总是很高兴学习新东西。谢谢!它是否总是返回对同一对象的引用,还是每次调用默认语句时都创建一个新实例?到目前为止,我在网上还没有找到任何东西,但是如果每次都创建一个新实例,则可能会破坏我一直在寻找的目的(具有一个线性的^^)。
Mallox

1
这样会不会为枚举中的每次迭代创建一个新实例?
Mallox 2011年

1
-1表示“在编译时支持类型检查:”。什么类型的检查?这将适用于任何new() T。此外,您new T()根本不需要,您可以仅选择静态字段并执行.GetValue(null)。请参阅Aubrey的答案。
nawfal 2014年

2
从C#7.3(Visual Studio 2017≥v15.7)开始,可以使用where T: Enum
Yahoo严重


50
public void PrintAllSuits()
{
    foreach(string suit in Enum.GetNames(typeof(Suits)))
    {
        Console.WriteLine(suit);
    }
}

2
它枚举了一个字符串,不要忘记将这些内容转换回枚举值,以便可以枚举枚举。
伊恩·博伊德

1
从您的编辑中可以看出,您想对枚举本身进行实际操作,上面的代码解决了您的原始帖子。
Joshua Drake 2010年

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

我听过模糊的传言,说这太慢了。有人知道吗 – Orion Edwards 08年10月15日在1:31 7

我认为缓存阵列将大大加快速度。看起来您每次都在获取一个新数组(通过反射)。而是:

Array enums = Enum.GetValues(typeof(Suit));
foreach (Suit suitEnum in enums) 
{
    DoSomething(suitEnum);
}

至少快一点,对吗?


5
但是,编译器应注意这一点。
Stephan Bijzitter 2015年

@StephanBijzitter哇,您在阅读这本书时还远远不够:-)我同意,编译器应使我的解决方案变得不必要。
有限赎罪2015年

1
这不是必需的。查看ILSpy中的编译代码,编译器肯定已经做到了。为什么根本不赞成这个答案,却少了35次?
mhenry1384

1
很久以前它被否决了。很久以前。我敢打赌,编译器也会在那时解决这个问题。但是它确实看起来更有表现,不是吗?;-)
有限赎罪

32

三种方式:

  1. Enum.GetValues(type) //从.NET 1.1开始,不在Silverlight或.NET Compact Framework中
  2. type.GetEnumValues() //仅在.NET 4及更高版本上
  3. type.GetFields().Where(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)));
    }
}

这是一个很好的方法总结。我认为您应该将其他答案合并到此。事实是枚举是特殊的,遍历它们通常(通常)与枚举一样有效,因为您知道值永远不会改变。IOW,如果您的枚举始终在变化,那么您选择的数据构造错误。
krowe2

31

仅仅通过组合最重要的答案,我就得出了一个非常简单的扩展:

public static class EnumExtensions
{
    /// <summary>
    /// Gets all items for an enum value.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="value">The value.</param>
    /// <returns></returns>
    public static IEnumerable<T> GetAllItems<T>(this T value) where T : Enum
    {
        return (T[])Enum.GetValues(typeof (T));
    }
}

它干净,简单,并且通过@ Jeppe-Stig-Nielsen的评论,速度很快。


6
从C#7.3(Visual Studio 2017≥v15.7)开始,可以使用where T: Enum
Yahoo严重

24

有两种方法可以迭代Enum

1. var values =  Enum.GetValues(typeof(myenum))
2. var values =  Enum.GetNames(typeof(myenum))

第一个将以** object** 数组形式提供值,第二个将以**数组形式提供值String ** s。

foreach如下循环使用它:

foreach(var value in values)
{
    // Do operations here
}

2
也许因为这已经被很多答案所涵盖了?我们不要使答案多余。
nawfal

@nawfal是,可能在其他答案中也有提及,尽管在大多数答案中结论并不理想。
Kylo Ren

23

我使用ToString()然后拆分并解析标记中的spit数组。

[Flags]
public enum ABC {
   a = 1,
   b = 2,
   c = 4
};

public IEnumerable<ABC> Getselected (ABC flags)
{
   var values = flags.ToString().Split(',');
   var enums = values.Select(x => (ABC)Enum.Parse(typeof(ABC), x.Trim()));
   return enums;
}

ABC temp= ABC.a | ABC.b;
var list = getSelected (temp);
foreach (var item in list)
{
   Console.WriteLine(item.ToString() + " ID=" + (int)item);
}

17

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

如果枚举值严格在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;
    }
}

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


16

如果需要在构建和运行时进行速度和类型检查,则此帮助器方法比使用LINQ强制转换每个元素更好:

public static T[] GetEnumValues<T>() where T : struct, IComparable, IFormattable, IConvertible
{
    if (typeof(T).BaseType != typeof(Enum))
    {
        throw new ArgumentException(string.Format("{0} is not of type System.Enum", typeof(T)));
    }
    return Enum.GetValues(typeof(T)) as T[];
}

您可以像下面这样使用它:

static readonly YourEnum[] _values = GetEnumValues<YourEnum>();

当然您可以返回IEnumerable<T>,但这在这里买不到任何东西。


3
从C#7.3(Visual Studio 2017≥v15.7)开始,可以使用where T: Enum
Yahoo严重

14

这是为DDL创建选择选项的工作示例:

var resman = ViewModelResources.TimeFrame.ResourceManager;

ViewBag.TimeFrames = from MapOverlayTimeFrames timeFrame
      in Enum.GetValues(typeof(MapOverlayTimeFrames))
      select new SelectListItem
      {
         Value = timeFrame.ToString(),
         Text = resman.GetString(timeFrame.ToString()) ?? timeFrame.ToString()
      };

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

(当前接受的答案具有我认为不需要的强制转换(尽管我可能错了)。)


10

该问题出现在“ C#Step by Step 2013 ”的第10章中 ”的

作者使用双for循环遍历一对枚举器(以创建一整套纸牌):

class Pack
{
    public const int NumSuits = 4;
    public const int CardsPerSuit = 13;
    private PlayingCard[,] cardPack;

    public Pack()
    {
        this.cardPack = new PlayingCard[NumSuits, CardsPerSuit];
        for (Suit suit = Suit.Clubs; suit <= Suit.Spades; suit++)
        {
            for (Value value = Value.Two; value <= Value.Ace; value++)
            {
                cardPack[(int)suit, (int)value] = new PlayingCard(suit, value);
            }
        }
    }
}

在这种情况下,SuitValue都是枚举:

enum Suit { Clubs, Diamonds, Hearts, Spades }
enum Value { Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King, Ace}

并且PlayingCard是具有确定的卡对象SuitValue

class PlayingCard
{
    private readonly Suit suit;
    private readonly Value value;

    public PlayingCard(Suit s, Value v)
    {
        this.suit = s;
        this.value = v;
    }
}

如果枚举中的值不是顺序的,这将起作用吗?
亚米尔马苏德


8

如果您知道类型将是enum,但不知道在编译时确切的类型该怎么办?

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

8

将枚举转换为可以交互的对象的简单通用方法:

public static Dictionary<int, string> ToList<T>() where T : struct
{
   return ((IEnumerable<T>)Enum
       .GetValues(typeof(T)))
       .ToDictionary(
           item => Convert.ToInt32(item),
           item => item.ToString());
}

然后:

var enums = EnumHelper.ToList<MyEnum>();

A Dictionary不是一个好主意:如果您有一个Enumlike enum E { A = 0, B = 0 },则将0值相加两次生成一个ArgumentException(您不能KeyDictionary2次或多次上添加相同值!)。
Massimiliano Kraus 2016年

为什么Dictionary<,>要从名为方法的方法返回ToList?又为什么不回来Dictionary<T, string>
Aluan Haddad

8

将方法添加public static IEnumerable<T> GetValues<T>()到您的类中,例如:

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

调用并传递您的枚举。现在,您可以使用进行迭代foreach

 public static void EnumerateAllSuitsDemoMethod()
 {
     // Custom method
     var foos = GetValues<Suit>();
     foreach (var foo in foos)
     {
         // Do something
     }
 }

2

enum类型称为“枚举类型”,不是因为它们是“枚举”值(不是)的容器,而是因为它们是通过枚举定义的该类型变量的可能值来。

(实际上,这要复杂得多-枚举类型被认为具有“底层”整数类型,这意味着每个枚举值都对应一个整数值(这通常是隐式的,但可以手动指定)。C#是设计的以某种方式可以塞满任何东西将该类型的整数到enum变量中,即使它不是“命名”值也是如此。)

System.Enum.GetNames方法可用于检索字符串其是枚举值的名称的数组,顾名思义。

编辑:应该建议System.Enum.GetValues方法来代替。哎呀。


2
尽管您的回答本身是正确的,但并不能真正解决OP的原始问题。该GetNames方法的确返回一个字符串数组,但是OP要求通过值进行枚举。
西尔维·普雷达

@SilviuPreda:编辑。应该是GetValues而不是GetNames。
陈慧娴

2

我尝试了很多方法,并从以下代码获得了结果:

要从枚举获取int列表,请使用以下内容。有用!

List<int> listEnumValues = new List<int>();
YourEnumType[] myEnumMembers = (YourEnumType[])Enum.GetValues(typeof(YourEnumType));
foreach ( YourEnumType enumMember in myEnumMembers)
{
    listEnumValues.Add(enumMember.GetHashCode());
}

1
tanx编辑@ peter-mortensen
reza akhlaghi

0

您也可以使用反射直接绑定到枚举的公共静态成员:

typeof(Suit).GetMembers(BindingFlags.Public | BindingFlags.Static)
    .ToList().ForEach(x => DoSomething(x.Name));

0

如果你有:

enum Suit
{
   Spades,
   Hearts,
   Clubs,
   Diamonds
}

这个:

foreach (var e in Enum.GetValues(typeof(Suit)))
{
    Console.WriteLine(e.ToString() + " = " + (int)e);
}

将输出:

Spades = 0
Hearts = 1
Clubs = 2
Diamonds = 3

0

LINQ通用方式:

    public static Dictionary<int, string> ToList<T>() where T : struct =>
        ((IEnumerable<T>)Enum.GetValues(typeof(T))).ToDictionary(value => Convert.ToInt32(value), value => value.ToString());

用法:

        var enums = ToList<Enum>();
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.