C# 作为枚举的键值对

我可以有一个作为键值对的枚举吗

public enum infringementCategory
{ 
    Infringement,
    OFN
}

如果我选择

侵权

我应该得到“INF0001”，如果我选择

OFN

我应该得到“INF0002”

---

可能吗？

您可以存储标题（INF0001）。。。在

字典中

可以使用修饰符将字符串表示与枚举值相关联。检查此问题：

它看起来像：

public enum infringementCategory
{ 
    [Description("INF0001")]
    Infringement,
    [Description("INF0002")]
    OFN
}

---

看起来比使用字典更整洁，需要的维护更少。

更新：
谢谢奥利弗的指点。以下是如何做到这一点：

public enum infringementCategory
{
    [Description("INF0001")]
    Infringement,
    [Description("INF0002")]
    OFN
}

public static class DescriptionExtensions
{
    public static string GetDescriptionValue(this Enum value)
    {
        // Get the type
        Type type = value.GetType();

        // Get fieldinfo for this type
        FieldInfo fieldInfo = type.GetField(value.ToString());

        // Get the stringvalue attributes
        DescriptionAttribute[] attribs = fieldInfo.GetCustomAttributes(
            typeof(DescriptionAttribute), false) as DescriptionAttribute[];

        // Return the first if there was a match.
        return attribs.Length > 0 ? attribs[0].Description : null;
    }
}

public class Program
{
    static void Main(string[] args)
    {
        infringementCategory category = infringementCategory.OFN;
        string description = category.GetDescriptionValue();
    }
}

---

您有许多选择：

vc74建议的词典。这是有效的，并将枚举与属性解耦

switch语句

如果您只想与每个对象关联一个整数，则可以使用：

 public enum InfringementCategory
 { 
     Infringement = 1,
     OFN = 2
 }

然后将

（int）myEnum

放入

String.Format

中，将其转换为所需格式的字符串

属性

public enum InfringementCategory
{ 
    [InfID("INF0001")]Infringement,
    [InfID("INF0002")]OFN
}

为了提高性能，您可以使用反射一次来填充字典

---

这些扩展如何：

public static class EnumExtension
{
    /// <summary>
    /// Gets the string of an DescriptionAttribute of an Enum.
    /// </summary>
    /// <param name="value">The Enum value for which the description is needed.</param>
    /// <returns>If a DescriptionAttribute is set it return the content of it.
    /// Otherwise just the raw name as string.</returns>
    public static string Description(this Enum value)
    {
        if (value == null)
        {
            throw new ArgumentNullException("value");
        }

        string description = value.ToString();
        FieldInfo fieldInfo = value.GetType().GetField(description);
        DescriptionAttribute[] attributes =
           (DescriptionAttribute[])
         fieldInfo.GetCustomAttributes(typeof(DescriptionAttribute), false);

        if (attributes != null && attributes.Length > 0)
        {
            description = attributes[0].Description;
        }

        return description;
    }

    /// <summary>
    /// Creates an List with all keys and values of a given Enum class
    /// </summary>
    /// <typeparam name="T">Must be derived from class Enum!</typeparam>
    /// <returns>A list of KeyValuePair&lt;Enum, string&gt; with all available
    /// names and values of the given Enum.</returns>
    public static IList<KeyValuePair<Enum, string>> ToList<T>() where T : struct
    {
        var type = typeof(T);

        if (!type.IsEnum)
        {
            throw new ArgumentException("T must be an enum");
        }

        return (IList<KeyValuePair<Enum, string>>)
                Enum.GetValues(type)
                    .OfType<Enum>()
                    .Select(e => new KeyValuePair<Enum, string>(e, e.Description()))
                    .ToArray();
    }

    public static T GetValueFromDescription<T>(string description) where T : struct
    {
        var type = typeof(T);

        if(!type.IsEnum)
        {
            throw new ArgumentException("T must be an enum");
        }

        foreach(var field in type.GetFields())
        {
            var attribute = Attribute.GetCustomAttribute(field,
                typeof(DescriptionAttribute)) as DescriptionAttribute;

            if(attribute != null)
            {
                if(attribute.Description == description)
                {
                    return (T)field.GetValue(null);
                }
            }
            else
            {
                if(field.Name == description)
                {
                    return (T)field.GetValue(null);
                }
            }
        }

        throw new ArgumentOutOfRangeException("description");
        // or return default(T);
    }
}

下面是您的列表：

public enum Foo
{
    [Description("Foo - Something")]
    Something,
    [Description("Foo - Anything")]
    Anything,
}

var list = EnumExtension.ToList<Foo>();

var list=EnumExtension.ToList（）；

请参见：

这里是扩展方法

#region [ EnumNamedConstantAttribute ]
[AttributeUsage(AttributeTargets.Field, AllowMultiple = false)]
public class EnumNamedConstantAttribute : Attribute
{
    public string Description { get; set; }
    public string Value { get; set; }
}
#endregion


#region EnumUtilities
public static class EnumUtilities
{
    #region [ + Extension Methods ]

    #region [ GetDescription ]

    public static string GetDescription(this Enum constant)
    {
        return EnumUtilities.GetEnumNamedConstantAttribute(constant).Description;
    }
    #endregion

    #region [ GetStringValue ]

    public static string GetStringValue(this Enum constant)
    {
        return GetEnumNamedConstantValue(constant);
    }
    #endregion

    #endregion

    #region [ + Static Methods ]

    #region [ GetEnumerable ]

    public static IEnumerable<EnumNamedConstantAttribute> GetEnumerable<T>()
    {
        T instancia = Activator.CreateInstance<T>();

        FieldInfo[] objInfos = instancia.GetType().GetFields(BindingFlags.Public | BindingFlags.Static);
        foreach (FieldInfo objFileInfo in objInfos)
        {
            Enum constant = (Enum)objFileInfo.GetValue(objFileInfo);
            if (objFileInfo.GetCustomAttributes(typeof(EnumNamedConstantAttribute), false).Length != 0)
            {
                yield return new EnumNamedConstantAttribute()
                {
                    Description = EnumUtilities.GetEnumNamedConstantAttribute(constant).Description,
                    Value = GetEnumNamedConstantValue(constant)
                };
            }
        }
    }
    #endregion

    #endregion

    #region [ + Privates ]

    #region [ GetEnumNamedConstantAttribute ]
    private static EnumNamedConstantAttribute GetEnumNamedConstantAttribute(Enum constant)
    {
        FieldInfo[] objInfos = constant.GetType().GetFields(BindingFlags.Public | BindingFlags.Static);
        foreach (FieldInfo objFileInfo in objInfos)
        {
            Enum constantItem = (Enum)objFileInfo.GetValue(objFileInfo);
            if (constantItem.GetHashCode().Equals(constant.GetHashCode()))
            {
                object[] attributes = objFileInfo.GetCustomAttributes(typeof(EnumNamedConstantAttribute), false);

                if (attributes.Length > 0)
                    return (EnumNamedConstantAttribute)attributes[0];
            }
        }
        return null;
    }
    #endregion

    #region [ GetEnumNamedConstantValue ]
    private static string GetEnumNamedConstantValue(Enum constant)
    {
        string sValue = (constant.GetHashCode()).ToString();
        EnumNamedConstantAttribute objRet = EnumUtilities.GetEnumNamedConstantAttribute(constant);
        if (objRet != null)
        {
            String sAux = objRet.Value;
            if (!String.IsNullOrEmpty(sAux))
                sValue = objRet.Value;
        }
        return sValue;
    }
    #endregion

    #endregion
}
#endregion

#区域[EnumNamedConstantAttribute]
[AttributeUsage（AttributeTargets.Field，AllowMultiple=false）]
公共类EnumNamedConstantAttribute:属性
{
公共字符串说明{get；set；}
公共字符串值{get；set；}
}
#端区
#区域枚举实用程序
公共静态类枚举实用程序
{
#区域[+扩展方法]
#区域[GetDescription]
公共静态字符串GetDescription（此枚举常量）
{
返回EnumUtilities.GetEnumNamedConstantAttribute（常量）.Description；
}
#端区
#区域[GetStringValue]
公共静态字符串GetStringValue（此枚举常量）
{
返回GetEnumNamedConstantValue（常量）；
}
#端区
#端区
#区域[+静态方法]
#区域[GetEnumerable]
公共静态IEnumerable GetEnumerable（）
{
T instancia=Activator.CreateInstance（）；
FieldInfo[]objInfos=instancia.GetType（）.GetFields（BindingFlags.Public | BindingFlags.Static）；
foreach（objInfos中的FieldInfo objFileInfo）
{
枚举常量=（Enum）objFileInfo.GetValue（objFileInfo）；
if（objFileInfo.GetCustomAttributes（typeof（EnumNamedConstantAttribute），false）。长度！=0）
{
返回新的EnumNamedConstantAttribute（）
{
Description=EnumUtilities.GetEnumNamedConstantAttribute（常量）。Description，
值=GetEnumNamedConstantValue（常量）
};
}
}
}
#端区
#端区
#地区[+私人]
#区域[GetEnumNamedConstantAttribute]
私有静态EnumNamedConstantAttribute GetEnumNamedConstantAttribute（枚举常量）
{
FieldInfo[]objInfos=constant.GetType（）.GetFields（BindingFlags.Public | BindingFlags.Static）；
foreach（objInfos中的FieldInfo objFileInfo）
{
Enum constantItem=（Enum）objFileInfo.GetValue（objFileInfo）；
if（constantItem.GetHashCode（）.Equals（constant.GetHashCode（）））
{
object[]attributes=objFileInfo.GetCustomAttributes（typeof（EnumNamedConstantAttribute），false）；
如果（attributes.Length>0）
返回（EnumNamedConstantAttribute）属性[0]；
}
}
返回null；
}
#端区
#区域[GetEnumNamedConstantValue]
私有静态字符串GetEnumNamedConstantValue（枚举常量）
{
字符串sValue=（constant.GetHashCode（））.ToString（）；
EnumNamedConstantAttribute objRet=EnumUtilities.GetEnumNamedConstantAttribute（常量）；
if（objRet！=null）
{
字符串sAux=objRet.Value；
如果（！String.IsNullOrEmpty（sAux））
S值=对象集值；
}
返回值；
}
#端区
#端区
}
#端区

如果可以，为什么要使用自写属性？@Oliver我同意，尽管这篇博文也有一个获取属性值的扩展方法。在您的情况下，Enum的可能重复项不是一个好选择，请改用Dictionary。

#region [ EnumNamedConstantAttribute ]
[AttributeUsage(AttributeTargets.Field, AllowMultiple = false)]
public class EnumNamedConstantAttribute : Attribute
{
    public string Description { get; set; }
    public string Value { get; set; }
}
#endregion


#region EnumUtilities
public static class EnumUtilities
{
    #region [ + Extension Methods ]

    #region [ GetDescription ]

    public static string GetDescription(this Enum constant)
    {
        return EnumUtilities.GetEnumNamedConstantAttribute(constant).Description;
    }
    #endregion

    #region [ GetStringValue ]

    public static string GetStringValue(this Enum constant)
    {
        return GetEnumNamedConstantValue(constant);
    }
    #endregion

    #endregion

    #region [ + Static Methods ]

    #region [ GetEnumerable ]

    public static IEnumerable<EnumNamedConstantAttribute> GetEnumerable<T>()
    {
        T instancia = Activator.CreateInstance<T>();

        FieldInfo[] objInfos = instancia.GetType().GetFields(BindingFlags.Public | BindingFlags.Static);
        foreach (FieldInfo objFileInfo in objInfos)
        {
            Enum constant = (Enum)objFileInfo.GetValue(objFileInfo);
            if (objFileInfo.GetCustomAttributes(typeof(EnumNamedConstantAttribute), false).Length != 0)
            {
                yield return new EnumNamedConstantAttribute()
                {
                    Description = EnumUtilities.GetEnumNamedConstantAttribute(constant).Description,
                    Value = GetEnumNamedConstantValue(constant)
                };
            }
        }
    }
    #endregion

    #endregion

    #region [ + Privates ]

    #region [ GetEnumNamedConstantAttribute ]
    private static EnumNamedConstantAttribute GetEnumNamedConstantAttribute(Enum constant)
    {
        FieldInfo[] objInfos = constant.GetType().GetFields(BindingFlags.Public | BindingFlags.Static);
        foreach (FieldInfo objFileInfo in objInfos)
        {
            Enum constantItem = (Enum)objFileInfo.GetValue(objFileInfo);
            if (constantItem.GetHashCode().Equals(constant.GetHashCode()))
            {
                object[] attributes = objFileInfo.GetCustomAttributes(typeof(EnumNamedConstantAttribute), false);

                if (attributes.Length > 0)
                    return (EnumNamedConstantAttribute)attributes[0];
            }
        }
        return null;
    }
    #endregion

    #region [ GetEnumNamedConstantValue ]
    private static string GetEnumNamedConstantValue(Enum constant)
    {
        string sValue = (constant.GetHashCode()).ToString();
        EnumNamedConstantAttribute objRet = EnumUtilities.GetEnumNamedConstantAttribute(constant);
        if (objRet != null)
        {
            String sAux = objRet.Value;
            if (!String.IsNullOrEmpty(sAux))
                sValue = objRet.Value;
        }
        return sValue;
    }
    #endregion

    #endregion
}
#endregion