Question

我有一个像

这样的枚举

public enum DecimailPrecision
        {
            One,
            Two,
        }

和课程为

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

我需要更好的方法因为我在枚举中有很多项目。

感谢。

Answer 1

为什么不创建一个Dictionary<DecimailPrecision, string>并保留映射？

这样您就可以在字典中查找DecimailPrecision值并检索相应的映射字符串。

您甚至可以将映射存储在config中并从中读取，因此您无需重新编译代码即可添加新的映射。

要明确地将其应用于您的代码（我建议您将const的名称更改为DecimalPrecisionFormat）：

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

var formatTwo = precisionMap[DecimailPrecision.Two];

Answer 2

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

用法是这样的。

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

Extensions和Atrribute就像：

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

使用枚举从类c中检索const值＃

2 个答案: