使用enum从c#类中检索const值

本文关键字：检索 const enum 使用 | 更新日期: 2023-09-27 18:07:00

我有一个类似

的enum
public enum DecimailPrecision
        {
            One,
            Two,
        }

和class为

class DecimailPrecision1
        {
            public const string One = "#,##0.0";
            public const string Two = "#,##0.00";
        }

我想从带有enum的类中检索const字符串。我已经用if和

切换过了
 string format = string.Empty;
switch (value)
{
case DecimailPrecision.One:
     format = DecimailPrecision1.One.ToString(); break;
case DecimailPrecision.Two:
     format = DecimailPrecision1.Two.ToString(); break;
default:
     format = DecimailPrecision1.Two.ToString(); break;
}
if (value == "One"){
   format = DecimailPrecision1.One.ToString();}
else if (value == "Two"){
   format = DecimailPrecision1.Two.ToString();}
}

我需要一个更好的方法，因为我在enum中有很多项。

谢谢。

使用enum从c#类中检索const值

为什么不创建一个Dictionary<DecimailPrecision, string>并在其中保存映射?

这样，您可以简单地在字典中查找您的DecimailPrecision值并检索适当映射的字符串。

你甚至可以将映射存储在config中并从中读取它，这样你就不需要重新编译代码来添加新的映射。

要显式地将此应用于您的代码(我建议将const s的名称更改为DecimalPrecisionFormat):

var precisionMap = new Dictionary<DecimailPrecision, string> 
{ 
    { DecimailPrecision.One, DecimailPrecision1.One }
  , { DecimailPrecision.Two, DecimailPrecision1.Two } 
};
var formatTwo = precisionMap[DecimailPrecision.Two];

对于类似的需求，我们开发了一个自定义属性和一些扩展方法。

用法如下。

public enum DecimailPrecision
{
    [EnumCode("#,##0.0")]
    One,
    [EnumCode("#,##0.00")]
    Two
}
string format = DecimailPrecision.One.GetCode();

对于您的情况可能没有意义，但反过来是有效的，像这样

string format ="#,##0.00";
DecimailPrecision dp = format.ToEnum<DecimailPrecision>();

扩展和属性类似:

public static class EnumExtensions
{
    private static readonly Dictionary<Type, EnumCodePair[]> EnumCodeCache = new Dictionary<Type, EnumCodePair[]>();
    public static string GetCode(this Enum enumValue) {
        var codePairs = GetEnumCodePairs(enumValue.GetType());
        return codePairs.First(cp => Equals(cp.Enum, enumValue)).Code;
    }
    public static T ToEnum<T>(this string enumCode) {
        var codePairs = GetEnumCodePairs(typeof(T));
        return (T)codePairs.First(cp => Equals(cp.Code, enumCode)).Enum;
    }
    private static IEnumerable<EnumCodePair> GetEnumCodePairs(Type type) {
        if(!EnumCodeCache.ContainsKey(type)) {
            var enumFields = type.GetFields(BindingFlags.Public | BindingFlags.Static);
            var codePairs = new List<EnumCodePair>();
            foreach(var enumField in enumFields) {
                var enumValue = Enum.Parse(type, enumField.Name);
                var codePair = new EnumCodePair {
                    Enum = enumValue
                };
                var attrs = enumField.GetCustomAttributes(typeof(EnumCodeAttribute), false);
                codePair.Code = attrs.Length == 0
                                    ? enumField.Name
                                    : ((EnumCodeAttribute)attrs[0]).Code;
                codePairs.Add(codePair);
            }
            EnumCodeCache.Add(type, codePairs.ToArray());
        }
        return EnumCodeCache[type];
    }
    class EnumCodePair
    {
        public object Enum { get; set; }
        public string Code { get; set; }
    }
}
[AttributeUsage(AttributeTargets.Field, AllowMultiple = false)]
public class EnumCodeAttribute : Attribute
{
    public EnumCodeAttribute(string code) {
        Code = code;
    }
    public string Code { get; private set; }
}
相关文章：