枚举帮助方法，枚举数据注解自定义验证器

枚举辅助类

• 获取枚举项列表
• 获取枚举值列表
• 枚举项包含
• 枚举值包含
• 转换枚举

代码如下

    /// <summary>
    /// 枚举辅助类
    /// </summary>
    public class EnumHelper
    {

        private static readonly Dictionary<Type, object> EnumCache = new Dictionary<Type, object>();

        private static readonly Dictionary<Type, object> EnumValueCache = new Dictionary<Type, object>();
        /// <summary>
        /// 取得枚举值列表
        /// </summary>
        public static List<T> GetEnumList<T>()
        {
            var t = typeof(T);
            if (!t.IsEnum)
            {
                return null;
            }
            if (EnumCache.ContainsKey(t))
            {
                return (List<T>)EnumCache[t];
            }
            var arr = Enum.GetValues(t);
            var values = new List<T>();
            var eor = arr.GetEnumerator();
            while (eor.MoveNext())
            {
                values.Add((T)eor.Current);
            }
            EnumCache[t] = values;
            return values;
        }

        /// <summary>
        /// 取得枚举值列表
        /// </summary>
        public static List<int> GetEnumValueList<T>()
        {
            var t = typeof(T);
            return GetEnumValueList(t);
        }

        /// <summary>
        /// 取得枚举值列表
        /// </summary>
        public static List<int> GetEnumValueList(Type t)
        {
            if (!t.IsEnum)
            {
                return null;
            }

            if (EnumValueCache.ContainsKey(t))
            {
                return (List<int>)EnumValueCache[t];
            }
            var arr = Enum.GetValues(t);
            var values = new List<int>();
            var eor = arr.GetEnumerator();
            while (eor.MoveNext())
            {
                // ReSharper disable once PossibleNullReferenceException
                values.Add((int)eor.Current);
            }
            EnumValueCache[t] = values;
            return values;

        }
        
        /// <summary>
        /// 枚举包含值
        /// </summary>
        public static bool EnumIncludeValue<T>(int val)
        {
            var enums = GetEnumValueList<T>();
            return enums != null && enums.Contains(val);
        }

        /// <summary>
        /// 枚举包含值
        /// </summary>
        public static bool EnumInclude<T>(T val)
        {
            var enums = GetEnumList<T>();
            return enums != null && enums.Contains(val);
        }

        /// <summary>
        /// 转换为枚举
        /// </summary>
        public static T ParseEnum<T>(int value)
        {
            return ParseEnum<T>(value.ToString());
        }

        /// <summary>
        /// 转换为枚举
        /// </summary>
        /// <param name="value">包含要转换的值或名称的字符串</param>
        /// <returns>枚举</returns>
        public static T ParseEnum<T>(string value)
        {
            return (T)Enum.Parse(typeof(T), value);
        }

    }

自定义了枚举值数据注解特性EnumValueAttribute

实现枚举值有效验证，如果枚举值不在枚举项中，则验证不通过。

    /// <summary>
    /// 枚举值正确性验证
    /// </summary>
    [AttributeUsage(AttributeTargets.Property)]
    public class EnumValueAttribute : ValidationAttribute
    {
        /// <summary>
        /// 是否需要验证上下文
        /// </summary>
        public override bool RequiresValidationContext => true;

        /// <summary>
        /// 是否有效
        /// </summary>
        /// <param name="value">要验证的枚举值</param>
        /// <param name="validationContext">验证上下文</param>
        /// <returns><see cref="ValidationResult"/>对象实例</returns>
        protected override ValidationResult IsValid(object value, ValidationContext validationContext)
        {
            var t = value.GetType();
            if (!t.IsEnum) { ExceptionHelper.ThrowProgramException("EnumValue只能附加到枚举属性上",UtilityErrors.ProgramNotImplement);}
            var values = EnumHelper.GetEnumValueList(t);
            return !values.Contains((int)value) ? new ValidationResult(FormatErrorMessage(validationContext.MemberName)) : null;
        }
    }

单元测试代码

    /// <summary>
    /// 使用SharpZipLib来完成打包解包
    /// </summary>
    [TestClass]
    public class ValidateTests
    {

        /// <summary>
        /// 打包压缩文件夹测试
        /// </summary>
        [TestMethod]
        public void ValidateTest()
        {
            TestEnums a = (TestEnums) 6;
            TestEnums b = (TestEnums) 3;
            var c=EnumHelper.GetEnumValueList<TestEnums>().Contains(6);
            var containsA = EnumHelper.EnumInclude(a);
            var containsB = EnumHelper.EnumInclude(b);
            var model = new ValidateModel
            {
                AdminInitPassword = "123",
                IntTest = 100,
                Enum1 = 4,
                Password1 = "12345",
                Password2 = "123451",
                RegexValue = "1235",
                Nest = new NestModel { String1 = "string1" }
            };
            // 获取验证结果列表
            var results = model.GetValidateResults();

            Assert.IsTrue(results.Count == 6);
            ////////// 验证模型是否有效
            ////////bool valid = model.ValidateValid();
            ////////// 抛出验证结果集中的 第一条验证不通过信息
            ////////model.ThrowValidateResult();
            ////////// 抛出验证结果集中的 所有验证不通过信息
            ////////model.ThrowValidateResults();
        }

        [CustomValidation(typeof(ValidateModel), "ValidateNestModel")]
        public class NestModel
        {
            public string String1 { get; set; }
        }

        public class ValidateModel : IValidateModel
        {
            [Range(1000, 6000, ErrorMessage = "值要在1000-6000")]
            public int IntTest { get; set; }
            [MinLength(5, ErrorMessage = "至少五个字符")]
            public string Password1 { get; set; }
            [Compare("Password1", ErrorMessage = "两次密码不同")]
            public string Password2 { get; set; }
            [EmailAddress(ErrorMessage = "错误的邮件地址")]
            public string Email { get; set; }
            [RegularExpression(@"^d{4}$", ErrorMessage = "格式错误")]
            public string RegexValue { get; set; }

            public int Enum1 { get; set; }

            [EnumValue(ErrorMessage = "枚举值{0}无效")]
            public TestEnums Enum2 => (TestEnums) Enum1;

            /// <summary>
            /// 管理员初始密码
            /// </summary>
            //[Required(ErrorMessage = "请输入密码")]
            //[CustomValidation(typeof(ValidateModel), "ValidateAdminInitPassword")]
            [CustomValidator(CustomValidatorKeys.TestCustomValidator)]
            //[StringLength(60, MinimumLength = 20, ErrorMessage = "20-60个字符")]
            public string AdminInitPassword { get; set; }

            //[Required(ErrorMessage = "对象为空")]
            //[CustomValidation(typeof(ValidateModel), "ValidateNestModel")]
            public NestModel Nest { get; set; }

            public static ValidationResult ValidateAdminInitPassword(string pwd, ValidationContext context)
            {
                var isValid = pwd == "123456";
                if (isValid)
                {
                    return ValidationResult.Success;
                }

                return new ValidationResult("2密码不是123456");
            }

            public static ValidationResult ValidateNestModel(NestModel model, ValidationContext context)
            {
                var isValid = model.String1 == "string2";
                if (isValid)
                {
                    return ValidationResult.Success;
                }

                return new ValidationResult("嵌套对象自定义验证不通过");
            }

        }

        public enum TestEnums
        {
            Item1 = 1,
            Item2 = 2,
            Item3 = 3
        }

    }

---

文章作者：花生（OutMan） 发布地址：http://www.cnblogs.com/WangHuaiSheng/  发布时间：2018-09-15 本文版权归作者和博客园共有，欢迎转载， 但未经作者同意必须保留此段声明， 且在文章页面明显位置给出原文连接。