小开

最佳答案

这应该能满足你的需要。

try
{
var enumType = typeof(FunkyAttributesEnum);
var memberInfos =
enumType.GetMember(FunkyAttributesEnum.NameWithoutSpaces1.ToString());
var enumValueMemberInfo = memberInfos.FirstOrDefault(m =>
m.DeclaringType == enumType);
var valueAttributes =
enumValueMemberInfo.GetCustomAttributes(typeof(DescriptionAttribute), false);
var description = ((DescriptionAttribute)valueAttributes[0]).Description;
}
catch
{
return FunkyAttributesEnum.NameWithoutSpaces1.ToString()
}

小开

或者，你可以这样做:

Dictionary<FunkyAttributesEnum, string> description = new Dictionary<FunkyAttributesEnum, string>()
{
{ FunkyAttributesEnum.NameWithoutSpaces1, "Name With Spaces1" },
{ FunkyAttributesEnum.NameWithoutSpaces2, "Name With Spaces2" },
};

并使用以下语句获取描述:

string s = description[FunkyAttributesEnum.NameWithoutSpaces1];

在我看来，这是一种更有效的方式去做你想要完成的事情，因为不需要思考。

小开

这是一个使用lambda进行选择的通用实现

public static Expected GetAttributeValue<T, Expected>(this Enum enumeration, Func<T, Expected> expression)
where T : Attribute
{
T attribute =
enumeration
.GetType()
.GetMember(enumeration.ToString())
.Where(member => member.MemberType == MemberTypes.Field)
.FirstOrDefault()
.GetCustomAttributes(typeof(T), false)
.Cast<T>()
.SingleOrDefault();


if (attribute == null)
return default(Expected);


return expression(attribute);
}

这样叫它:

string description = targetLevel.GetAttributeValue<DescriptionAttribute, string>(x => x.Description);

小开

这段代码应该为任何枚举提供了一个不错的扩展方法，使您可以检索泛型属性。我相信它与上面的lambda函数不同，因为它使用起来更简单，而且稍微-你只需要传入泛型类型。

public static class EnumHelper
{
/// <summary>
/// Gets an attribute on an enum field value
/// </summary>
/// <typeparam name="T">The type of the attribute you want to retrieve</typeparam>
/// <param name="enumVal">The enum value</param>
/// <returns>The attribute of type T that exists on the enum value</returns>
/// <example><![CDATA[string desc = myEnumVariable.GetAttributeOfType<DescriptionAttribute>().Description;]]></example>
public static T GetAttributeOfType<T>(this Enum enumVal) where T:System.Attribute
{
var type = enumVal.GetType();
var memInfo = type.GetMember(enumVal.ToString());
var attributes = memInfo[0].GetCustomAttributes(typeof(T), false);
return (attributes.Length > 0) ? (T)attributes[0] : null;
}
}

小开

我实现了这个扩展方法来从枚举值中获取描述。它适用于所有类型的枚举。

public static class EnumExtension
{
public static string ToDescription(this System.Enum value)
{
FieldInfo fi = value.GetType().GetField(value.ToString());
var attributes = (DescriptionAttribute[])fi.GetCustomAttributes(typeof(DescriptionAttribute), false);
return attributes.Length > 0 ? attributes[0].Description : value.ToString();
}
}

小开

除了AdamCrawford响应之外，我还进一步创建了一个更专门的扩展方法来获取它的描述。

public static string GetAttributeDescription(this Enum enumValue)
{
var attribute = enumValue.GetAttributeOfType<DescriptionAttribute>();
return attribute == null ? String.Empty : attribute.Description;
}

因此，要获得描述，您可以使用原始扩展方法as

string desc = myEnumVariable.GetAttributeOfType<DescriptionAttribute>().Description

或者你可以简单地调用这里的扩展方法:

string desc = myEnumVariable.GetAttributeDescription();

这应该会使您的代码更具可读性。

小开

下面是从Display属性获取信息的代码。它使用泛型方法检索属性。如果没有找到该属性，它将枚举值转换为字符串，pascal/camel大小写转换为标题大小写(代码获得在这里)

public static class EnumHelper
{
// Get the Name value of the Display attribute if the
// enum has one, otherwise use the value converted to title case.
public static string GetDisplayName<TEnum>(this TEnum value)
where TEnum : struct, IConvertible
{
var attr = value.GetAttributeOfType<TEnum, DisplayAttribute>();
return attr == null ? value.ToString().ToSpacedTitleCase() : attr.Name;
}


// Get the ShortName value of the Display attribute if the
// enum has one, otherwise use the value converted to title case.
public static string GetDisplayShortName<TEnum>(this TEnum value)
where TEnum : struct, IConvertible
{
var attr = value.GetAttributeOfType<TEnum, DisplayAttribute>();
return attr == null ? value.ToString().ToSpacedTitleCase() : attr.ShortName;
}


/// <summary>
/// Gets an attribute on an enum field value
/// </summary>
/// <typeparam name="TEnum">The enum type</typeparam>
/// <typeparam name="T">The type of the attribute you want to retrieve</typeparam>
/// <param name="value">The enum value</param>
/// <returns>The attribute of type T that exists on the enum value</returns>
private static T GetAttributeOfType<TEnum, T>(this TEnum value)
where TEnum : struct, IConvertible
where T : Attribute
{


return value.GetType()
.GetMember(value.ToString())
.First()
.GetCustomAttributes(false)
.OfType<T>()
.LastOrDefault();
}
}

这是字符串转换为title case的扩展方法:

    /// <summary>
/// Converts camel case or pascal case to separate words with title case
/// </summary>
/// <param name="s"></param>
/// <returns></returns>
public static string ToSpacedTitleCase(this string s)
{
//https://stackoverflow.com/a/155486/150342
CultureInfo cultureInfo = Thread.CurrentThread.CurrentCulture;
TextInfo textInfo = cultureInfo.TextInfo;
return textInfo
.ToTitleCase(Regex.Replace(s,
"([a-z](?=[A-Z0-9])|[A-Z](?=[A-Z][a-z]))", "$1 "));
}

小开

这个扩展方法将使用枚举值的XmlEnumAttribute获得枚举值的字符串表示形式。如果没有XmlEnumAttribute，则返回到枚举. tostring()。

public static string ToStringUsingXmlEnumAttribute<T>(this T enumValue)
where T: struct, IConvertible
{
if (!typeof(T).IsEnum)
{
throw new ArgumentException("T must be an enumerated type");
}


string name;


var type = typeof(T);


var memInfo = type.GetMember(enumValue.ToString());


if (memInfo.Length == 1)
{
var attributes = memInfo[0].GetCustomAttributes(typeof(System.Xml.Serialization.XmlEnumAttribute), false);


if (attributes.Length == 1)
{
name = ((System.Xml.Serialization.XmlEnumAttribute)attributes[0]).Name;
}
else
{
name = enumValue.ToString();
}
}
else
{
name = enumValue.ToString();
}


return name;
}

小开

我在这里合并了几个答案，以创建一个更具可扩展性的解决方案。我提供这些只是为了将来对其他人有所帮助。原创帖子在这里。

using System;
using System.ComponentModel;


public static class EnumExtensions {


// This extension method is broken out so you can use a similar pattern with
// other MetaData elements in the future. This is your base method for each.
public static T GetAttribute<T>(this Enum value) where T : Attribute {
var type = value.GetType();
var memberInfo = type.GetMember(value.ToString());
var attributes = memberInfo[0].GetCustomAttributes(typeof(T), false);
return attributes.Length > 0
? (T)attributes[0]
: null;
}


// This method creates a specific call to the above method, requesting the
// Description MetaData attribute.
public static string ToName(this Enum value) {
var attribute = value.GetAttribute<DescriptionAttribute>();
return attribute == null ? value.ToString() : attribute.Description;
}


}

这个解决方案在Enum上创建一对扩展方法。第一种方法允许您使用反射来检索与您的值相关的任何属性。第二个调用检索DescriptionAttribute并返回它的Description值。

例如，考虑使用System.ComponentModel中的DescriptionAttribute属性

using System.ComponentModel;


public enum Days {
[Description("Sunday")]
Sun,
[Description("Monday")]
Mon,
[Description("Tuesday")]
Tue,
[Description("Wednesday")]
Wed,
[Description("Thursday")]
Thu,
[Description("Friday")]
Fri,
[Description("Saturday")]
Sat
}

要使用上面的扩展方法，你现在只需调用下面的方法:

Console.WriteLine(Days.Mon.ToName());

或

var day = Days.Mon;
Console.WriteLine(day.ToName());

小开

伙计们，如果有帮助的话，我将与你们分享我的解决方案: 自定义属性的定义:

    [AttributeUsage(AttributeTargets.Field,AllowMultiple = false)]
public class EnumDisplayName : Attribute
{
public string Name { get; private set; }
public EnumDisplayName(string name)
{
Name = name;
}
}

现在因为我需要它在HtmlHelper扩展的HtmlHelper定义内:

public static class EnumHelper
{
public static string EnumDisplayName(this HtmlHelper helper,EPriceType priceType)
{
//Get every fields from enum
var fields = priceType.GetType().GetFields();
//Foreach field skipping 1`st fieldw which keeps currently sellected value
for (int i = 0; i < fields.Length;i++ )
{
//find field with same int value
if ((int)fields[i].GetValue(priceType) == (int)priceType)
{
//get attributes of found field
var attributes = fields[i].GetCustomAttributes(false);
if (attributes.Length > 0)
{
//return name of found attribute
var retAttr = (EnumDisplayName)attributes[0];
return retAttr.Name;
}
}
}
//throw Error if not found
throw new Exception("Błąd podczas ustalania atrybutów dla typu ceny allegro");
}
}

希望能有所帮助

小开

从enum中获取字典。

public static IDictionary<string, int> ToDictionary(this Type enumType)
{
return Enum.GetValues(enumType)
.Cast<object>()
.ToDictionary(v => ((Enum)v).ToEnumDescription(), k => (int)k);
}

现在把它叫做…

var dic = typeof(ActivityType).ToDictionary();

枚举描述Ext方法

public static string ToEnumDescription(this Enum en) //ext method
{
Type type = en.GetType();
MemberInfo[] memInfo = type.GetMember(en.ToString());
if (memInfo != null && memInfo.Length > 0)
{
object[] attrs = memInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false);
if (attrs != null && attrs.Length > 0)
return ((DescriptionAttribute)attrs[0]).Description;
}
return en.ToString();
}


public enum ActivityType
{
[Description("Drip Plan Email")]
DripPlanEmail = 1,
[Description("Modification")]
Modification = 2,
[Description("View")]
View = 3,
[Description("E-Alert Sent")]
EAlertSent = 4,
[Description("E-Alert View")]
EAlertView = 5
}

小开

流利的一句话…

这里我使用的是包含Name和Description属性的DisplayAttribute。

public static DisplayAttribute GetDisplayAttributesFrom(this Enum enumValue, Type enumType)
{
return enumType.GetMember(enumValue.ToString())
.First()
.GetCustomAttribute<DisplayAttribute>();
}

例子

public enum ModesOfTransport
{
[Display(Name = "Driving",    Description = "Driving a car")]        Land,
[Display(Name = "Flying",     Description = "Flying on a plane")]    Air,
[Display(Name = "Sea cruise", Description = "Cruising on a dinghy")] Sea
}


void Main()
{
ModesOfTransport TransportMode = ModesOfTransport.Sea;
DisplayAttribute metadata = TransportMode.GetDisplayAttributesFrom(typeof(ModesOfTransport));
Console.WriteLine("Name: {0} \nDescription: {1}", metadata.Name, metadata.Description);
}

输出

Name: Sea cruise
Description: Cruising on a dinghy

小开

我这回答设置一个组合框从枚举属性，这是伟大的。

然后，我需要编写反向代码，以便从框中获得选择并返回正确类型的enum。

我还修改了代码，以处理缺少属性的情况

为了下一个人的利益，这是我的最终解决方案

public static class Program
{
static void Main(string[] args)
{
// display the description attribute from the enum
foreach (Colour type in (Colour[])Enum.GetValues(typeof(Colour)))
{
Console.WriteLine(EnumExtensions.ToName(type));
}


// Get the array from the description
string xStr = "Yellow";
Colour thisColour = EnumExtensions.FromName<Colour>(xStr);


Console.ReadLine();
}


public enum Colour
{
[Description("Colour Red")]
Red = 0,


[Description("Colour Green")]
Green = 1,


[Description("Colour Blue")]
Blue = 2,


Yellow = 3
}
}


public static class EnumExtensions
{


// This extension method is broken out so you can use a similar pattern with
// other MetaData elements in the future. This is your base method for each.
public static T GetAttribute<T>(this Enum value) where T : Attribute
{
var type = value.GetType();
var memberInfo = type.GetMember(value.ToString());
var attributes = memberInfo[0].GetCustomAttributes(typeof(T), false);


// check if no attributes have been specified.
if (((Array)attributes).Length > 0)
{
return (T)attributes[0];
}
else
{
return null;
}
}


// This method creates a specific call to the above method, requesting the
// Description MetaData attribute.
public static string ToName(this Enum value)
{
var attribute = value.GetAttribute<DescriptionAttribute>();
return attribute == null ? value.ToString() : attribute.Description;
}


/// <summary>
/// Find the enum from the description attribute.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="desc"></param>
/// <returns></returns>
public static T FromName<T>(this string desc) where T : struct
{
string attr;
Boolean found = false;
T result = (T)Enum.GetValues(typeof(T)).GetValue(0);


foreach (object enumVal in Enum.GetValues(typeof(T)))
{
attr = ((Enum)enumVal).ToName();


if (attr == desc)
{
result = (T)enumVal;
found = true;
break;
}
}


if (!found)
{
throw new Exception();
}


return result;
}
}

｝

小开

如果你想要完整的名单你可以这样做

typeof (PharmacyConfigurationKeys).GetFields()
.Where(x => x.GetCustomAttributes(false).Any(y => typeof(DescriptionAttribute) == y.GetType()))
.Select(x => ((DescriptionAttribute)x.GetCustomAttributes(false)[0]).Description);

小开

利用一些较新的c#语言特性，你可以减少行数:

public static TAttribute GetEnumAttribute<TAttribute>(this Enum enumVal) where TAttribute : Attribute
{
var memberInfo = enumVal.GetType().GetMember(enumVal.ToString());
return memberInfo[0].GetCustomAttributes(typeof(TAttribute), false).OfType<TAttribute>().FirstOrDefault();
}


public static string GetEnumDescription(this Enum enumValue) => enumValue.GetEnumAttribute<DescriptionAttribute>()?.Description ?? enumValue.ToString();

小开

下面是AdamCrawford的答案的。net核心版本，使用System.Reflection.TypeExtensions;

public static class EnumHelper
{
/// <summary>
/// Gets an attribute on an enum field value
/// </summary>
/// <typeparam name="T">The type of the attribute you want to retrieve</typeparam>
/// <param name="enumVal">The enum value</param>
/// <returns>The attribute of type T that exists on the enum value</returns>
/// <example>string desc = myEnumVariable.GetAttributeOfType<DescriptionAttribute>().Description;</example>
public static T GetAttributeOfType<T>(this Enum enumVal) where T : System.Attribute
{
var type = enumVal.GetType();
var memInfo = type.GetMember(enumVal.ToString());
IEnumerable<Attribute> attributes = memInfo[0].GetCustomAttributes(typeof(T), false);
return (T)attributes?.ToArray()[0];
}
}

小开

添加我的解决方案的Net Framework和NetCore。

我在我的Net Framework实现中使用了这个:

public static class EnumerationExtension
{
public static string Description( this Enum value )
{
// get attributes
var field = value.GetType().GetField( value.ToString() );
var attributes = field.GetCustomAttributes( typeof( DescriptionAttribute ), false );


// return description
return attributes.Any() ? ( (DescriptionAttribute)attributes.ElementAt( 0 ) ).Description : "Description Not Found";
}
}

这并不适用于NetCore，所以我修改了它，这样做:

public static class EnumerationExtension
{
public static string Description( this Enum value )
{
// get attributes
var field = value.GetType().GetField( value.ToString() );
var attributes = field.GetCustomAttributes( false );


// Description is in a hidden Attribute class called DisplayAttribute
// Not to be confused with DisplayNameAttribute
dynamic displayAttribute = null;


if (attributes.Any())
{
displayAttribute = attributes.ElementAt( 0 );
}


// return description
return displayAttribute?.Description ?? "Description Not Found";
}
}

枚举的例子:

public enum ExportTypes
{
[Display( Name = "csv", Description = "text/csv" )]
CSV = 0
}

使用任何静态添加:

var myDescription = myEnum.Description();

小开

    public enum DataFilters
{
[Display(Name= "Equals")]
Equals = 1,// Display Name and Enum Name are same
[Display(Name= "Does Not Equal")]
DoesNotEqual = 2, // Display Name and Enum Name are different
}

在这个例子中它会产生错误1 "等于"

public static string GetDisplayName(this Enum enumValue)
{
var enumMember = enumValue.GetType().GetMember(enumValue.ToString()).First();
return enumMember.GetCustomAttribute<DisplayAttribute>() != null ? enumMember.GetCustomAttribute<DisplayAttribute>().Name : enumMember.Name;
}

所以如果是相同的返回enum名称而不是显示名称，因为 enumMember.GetCustomAttribute () 如果displayname和enum name相同，则返回null .....

小开

如果你的enum包含一个像Equals这样的值，你可能会在这里的许多答案中使用一些扩展遇到一些错误。这是因为通常假定typeof(YourEnum).GetMember(YourEnum.Value)只返回一个值，即enum的MemberInfo。这里有一个稍微安全一点的版本亚当·克劳福德的回答。

public static class AttributeExtensions
{
#region Methods


public static T GetAttribute<T>(this Enum enumValue) where T : Attribute
{
var type = enumValue.GetType();
var memberInfo = type.GetMember(enumValue.ToString());
var member = memberInfo.FirstOrDefault(m => m.DeclaringType == type);
var attribute = Attribute.GetCustomAttribute(member, typeof(T), false);
return attribute is T ? (T)attribute : null;
}


#endregion
}

小开

或者，你可以这样做:

List<SelectListItem> selectListItems = new List<SelectListItem>();


foreach (var item in typeof(PaymentTerm).GetEnumValues())
{
var type = item.GetType();
var name = type.GetField(item.ToString()).GetCustomAttributesData().FirstOrDefault()?.NamedArguments.FirstOrDefault().TypedValue.Value.ToString();
selectListItems.Add(new SelectListItem(name, type.Name));


}

小开

这就是我在不使用。net core 3.1的自定义helper或扩展的情况下解决它的方法。

类

public enum YourEnum
{
[Display(Name = "Suryoye means Arameans")]
SURYOYE = 0,
[Display(Name = "Oromoye means Syriacs")]
OROMOYE = 1,
}

剃须刀

@using Enumerations


foreach (var name in Html.GetEnumSelectList(typeof(YourEnum)))
{
<h1>@name.Text</h1>
}

小开

性能问题

如果你想要更好的性能，这是一种方法:

public static class AdvancedEnumExtensions
{
/// <summary>
/// Gets the custom attribute <typeparamref name="T"/> for the enum constant, if such a constant is defined and has such an attribute; otherwise null.
/// </summary>
public static T GetCustomAttribute<T>(this Enum value) where T : Attribute
{
return GetField(value)?.GetCustomAttribute<T>(inherit: false);
}


/// <summary>
/// Gets the FieldInfo for the enum constant, if such a constant is defined; otherwise null.
/// </summary>
public static FieldInfo GetField(this Enum value)
{
ulong u64 = ToUInt64(value);
return value
.GetType()
.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static)
.Where(f => ToUInt64(f.GetRawConstantValue()) == u64)
.FirstOrDefault();
}


/// <summary>
/// Checks if an enum constant is defined for this enum value
/// </summary>
public static bool IsDefined(this Enum value)
{
return GetField(value) != null;
}


/// <summary>
/// Converts the enum value to UInt64
/// </summary>
public static ulong ToUInt64(this Enum value) => ToUInt64((object)value);


private static ulong ToUInt64(object value)
{
switch (Convert.GetTypeCode(value))
{
case TypeCode.SByte:
case TypeCode.Int16:
case TypeCode.Int32:
case TypeCode.Int64:
return unchecked((ulong)Convert.ToInt64(value, CultureInfo.InvariantCulture));


case TypeCode.Byte:
case TypeCode.UInt16:
case TypeCode.UInt32:
case TypeCode.UInt64:
case TypeCode.Char:
case TypeCode.Boolean:
return Convert.ToUInt64(value, CultureInfo.InvariantCulture);


default: throw new InvalidOperationException("UnknownEnumType");
}
}
}

为什么这个有更好的性能?

因为除了它们还运行一堆我们不关心的其他代码之外，内置方法都使用与此非常相似的代码。c#的Enum代码通常都很糟糕。

上面的代码已经经过linq化和精简，所以它只包含我们关心的部分。

为什么内置代码很慢?

首先关于枚举. tostring () -vs-枚举. getname (..)

总是使用后者。(或者两者都不做更好，如下文将会清楚说明。)

ToString()在内部使用后者，但同样，也做了一堆我们不想要的其他事情，例如尝试组合标志，打印出数字等。我们只对枚举中定义的常量感兴趣。

枚举。GetName依次获取所有字段，为所有名称创建一个字符串数组，在它们的所有RawConstantValues上使用上述ToUInt64创建一个包含所有值的UInt64数组，根据UInt64值对两个数组进行排序，最后通过在UInt64-array中执行BinarySearch来找到我们想要的值的索引，从而从name-array中获取名称。

.．.然后我们把字段和排序的数组扔掉用这个名字重新找到字段。

一个词:“呃!”

小开

对于一些程序员的幽默，一行代码就像一个笑话:

public static string GetDescription(this Enum value) => value.GetType().GetMember(value.ToString()).First().GetCustomAttribute<DescriptionAttribute>() is DescriptionAttribute attribute ? attribute.Description : string.Empty;

以更易读的形式:

using System;
using System.ComponentModel;
using System.Linq;
using System.Reflection;


public static class EnumExtensions
{
// get description from enum:


public static string GetDescription(this Enum value)
{
return value.GetType().
GetMember(value.ToString()).
First().
GetCustomAttribute<DescriptionAttribute>() is DescriptionAttribute attribute
? attribute.Description
: throw new Exception($"Enum member '{value.GetType()}.{value}' doesn't have a [DescriptionAttribute]!");
}


// get enum from description:


public static T GetEnum<T>(this string description) where T : Enum
{
foreach (FieldInfo fieldInfo in typeof(T).GetFields())
{
if (fieldInfo.GetCustomAttribute<DescriptionAttribute>() is DescriptionAttribute attribute && attribute.Description == description)
return (T)fieldInfo.GetRawConstantValue();
}


throw new Exception($"Enum '{typeof(T)}' doesn't have a member with a [DescriptionAttribute('{description}')]!");
}
}

小开

布莱恩·罗和AdamCrawford谢谢你的回答!

但是如果有人需要方法来获取描述(而不是扩展)，你可以使用它:

string GetEnumDiscription(Enum EnumValue)
{
var type = EnumValue.GetType();
var memInfo = type.GetMember(EnumValue.ToString());
var attributes = memInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false);
return (attributes.Length > 0) ? ((DescriptionAttribute)attributes[0]).Description : null;
}

小开

模型

我们用这个模型来充实我们的价值观

public class MemberTypeModel : IDto
{
public string MemberAttributeName { get; set; }
public string MemberName { get; set; }
public int MemberValue { get; set; }
}

枚举

我们的目标是枚举

public enum MemberType
{
[FieldText("Yönetim Kurul Üyesi")]
BoardManager = 0,


[FieldText("Temsilci")]
Representative = 1,


[FieldText("Üye")]
Member = 2
}

辅助方法

我们将使用helper方法来获取自定义属性对象

public T GetMemberCustomText<T>(MemberType memberType) where T : Attribute
{
var enumType = memberType.GetType();
var name = Enum.GetName(enumType, memberType);
return enumType.GetField(name).GetCustomAttributes(false).OfType<T>().SingleOrDefault();
}

Get方法

首先，我们提取枚举值并将它们转换为枚举类型。然后，通过Linq选择查询我们知道;

MemberAttributeName字段与helper方法，
带有Enum的MemberName字段。GetName方法,

public List<MemberTypeModel> GetMemberTypes()
{
var memberTypes = Enum.GetValues(typeof(MemberType))
.Cast<MemberType>()
.Select(et => new MemberTypeModel
{
MemberAttributeName = GetMemberCustomText<FieldText>(et).Text,
MemberName = Enum.GetName(et.GetType(), et),
MemberValue = (int)et
}).ToList();
return memberTypes;
}

小开

我已经创建了一个扩展方法，它将返回c#中枚举中所有元素的描述。

public static List<string> GetAllEnumDescriptions(this Type enumType)
{
try
{
var enumList = Enum.GetValues(enumType).Cast<Enum>().ToList();
List<string> result = new List<string>();
foreach (var enumItem in enumList)
{
result.Add(enumItem.EnumDescription());
}
return result;
}
catch (Exception ex)
{
return new List<string>();
}
}

此方法将使用内置的EnumDescription()扩展方法添加枚举中元素的描述。

小开

NuGet包枚举。网有很好的支持:

var value = FunkyAttributesEnum.NameWithoutSpaces1;
string description = value.AsString(EnumFormat.Description); // => "Name With Spaces1"

这个包简单、直观、完整。
它是类型安全的，并具有缓存以避免重复反射

GitHub库有更多的信息，包括本机Enum的限制和功能演示:

获取属性;
国旗操作;
Enum格式(用于ToString或从string解析Enum);
使用Enums.GetMembers<MyEnum>()丰富迭代所有值;
等。

获取枚举值的属性

输出

类

剃须刀

性能问题

为什么内置代码很慢?

模型

枚举

辅助方法

Get方法