一个自己编写的验证框架.

项目开发的时候.经常会遇到各种验证..例如密码是否正确,用户名重复验证之类的...  如果把这些代码都写在一起的话..那么就会形成下面的这个格式..

 

..... 

我感觉这么写很正常的,对吧? 恩. 也可以把这些验证方法放在另一个地方.然后返回true/false什么的.  这样也能够体现分离.整洁啥的...

但是以后要在添加一个验证呢??  这样是不是就破坏了传说中的设计模式的开放/封装的原则? 

所以根据各种原因我写了这么一个简单的框架.. 

开始进入正文: 

　　我先说使用方法...

　　1. 第一步当然是引用程序集了...噗..

　　2. 实现自己的验证器类. 实现Ivalidator接口. 并指定要验证的类型. 以及验证失败的时候返回的错误信息. 

　　3. 将自己的验证器类添加到Validators这个类中的AddValidator方法里面.并传入相应的参数(1. 验证的类型,2 自定义的验证器类实例)

　　4. 在编写的程序中. 调用Validators类的Validate方法.

　　5. 返回值: 

　　　　a) 如果所有验证器都通过验证.会返回null,这个时候你的程序就可以继续作别的..例如.将用户插入数据库.. 

　　　　b) 如果有一个验证器没有通过. 则会返回验证器对应返回值. (ValidatorResult类型).. 这时你可以写一个全局的方法.然后传入这个类型．根据类型的值跳转，提示什么的．．　然后方法返回．．

　　6. 结束

　　这个是测试方法...  

 

  static void Main(string[] args)
        {

            ///这个在全局的地方配置..可以添加多个类型
            Validators.AddValidators<int>(typeof(int), new ValidatorByInt1(), new ValidatorByInt2());

            ///进行验证.
            int testValue = 1;
            ValidatorResult v = Validators.Validate<int>(testValue);
            Console.WriteLine(" value:{0}; result:{1}", testValue, v == null ? "正确" : v.ErrorMsg);

            testValue = 100;
            v = Validators.Validate<int>(testValue);
            Console.WriteLine(" value:{0}; result:{1}", testValue, v == null ? "正确" : v.ErrorMsg);


            testValue = -1;
            v = Validators.Validate<int>(testValue);
            Console.WriteLine(" value:{0}; result:{1}", testValue, v == null ? "正确" : v.ErrorMsg);

            Console.ReadKey();
        }

 

 

　　这个是自己写的验证器类... 实现IValidator接口..

    public class ValidatorByInt1 : Validator<int>
    {
        public override ValidatorResult Validate(int model)
        {
            if (model > 10)
            {
                return new ValidatorResult() { ErrorCode = 1, ErrorMsg = "必须小于10" };
            }

            return ValidatorResult.Success;
        }
    }


    public class ValidatorByInt2 : Validator<int>
    {
        public override ValidatorResult Validate(int model)
        {
            if (model > 0)
            {
                return ValidatorResult.Success;
            }

            return new ValidatorResult() { ErrorCode = 1, ErrorMsg = "必须大于0" };
        }
    }

　　以下是程序集的代码

  /// <summary>
    /// 验证器接口,提供验证的功能
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IValidator<T>
    {
        ValidatorResult Validate(T model);
    }

    /// <summary>
    /// 继承于验证器接口... 没有实现任何成员
    /// 可添加成员
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public abstract partial class Validator<T> : IValidator<T>
    {
        public abstract ValidatorResult Validate(T model);
    }

    /// <summary>
    /// 验证结果..
    /// </summary>
    public class ValidatorResult
    {
        private int _ErrorCode = 0x0;
        private string _ErrorMsg = "";

        /// <summary>
        /// 表示验证成功.
        /// </summary>
        public static readonly ValidatorResult Success;

        /// <summary>
        /// 错误编号
        /// </summary>
        public virtual int ErrorCode
        {
            get { return _ErrorCode; }
            set { _ErrorCode = value; }
        }

        /// <summary>
        /// 错误信息
        /// </summary>
        public virtual string ErrorMsg
        {
            get { return _ErrorMsg; }
            set { _ErrorMsg = value; }
        }

        public ValidatorResult()
            //未知错误
            : this(0x1, "未知错误")
        { }

        public ValidatorResult(int errorCode, string errorMsg)
        {
            this._ErrorCode = errorCode;
            this._ErrorMsg = errorMsg;
        }
    }

    /// <summary>
    /// 验证器. 提供可以注册每个类型对应的验证器集合.以及验证每个验证器并返回验证器的结果.
    /// </summary>
    public class Validators
    {
        private static Dictionary<Type, Object> _AllValidator;

        /// <summary>
        /// 保存所有的验证器
        /// </summary>
        private static Dictionary<Type, Object> AllValidator
        {
            get { return Validators._AllValidator ?? (Validators._AllValidator = new Dictionary<Type, object>()); }
        }

        /// <summary>
        /// 给某个类型添加验证器.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="type">类型</param>
        /// <param name="validators">验证器数组</param>
        public static void AddValidators<T>(Type type, params IValidator<T>[] validators)
        {
            if (AllValidator.Keys.Contains(type))
            {
                AllValidator.Add(type, validators);
            }
            else
            {
                AllValidator[type] = validators;
            }

        }

        /// <summary>
        /// 移除验证器.并返回其验证器
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="type">要移除的类型</param>
        /// <returns></returns>
        public static IValidator<T>[] RemoveValidators<T>(Type type)
        {

            IValidator<T>[] value = default(IValidator<T>[]);

            if (AllValidator.Keys.Contains(type))
            {
                value = AllValidator[type] as IValidator<T>[];

                AllValidator.Remove(type);
            }

            return value;
        }


        /// <summary>
        /// 根据类型.获取其所有的验证器
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="type">要获取验证器数组的类型</param>
        /// <returns></returns>
        public static IValidator<T>[] GetValidators<T>(Type type)
        {
            if (AllValidator.Keys.Contains(type))
            {
                return AllValidator[type] as IValidator<T>[];
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// 清空所有验证器
        /// </summary>
        public static void Clear()
        {
            _AllValidator = null;
        }


        /// <summary>
        /// 对模型进行多个验证
        /// </summary>
        /// <typeparam name="T">要验证的模型的类型</typeparam>
        /// <param name="model">要验证的模型</param>
        /// <param name="validators">验证集合...</param>
        /// <returns></returns>
        public static ValidatorResult Validate<T>(T model)
        {
            ///获取验证器数组
            IValidator<T>[] validators = Validators.GetValidators<T>(model.GetType());

            ValidatorResult result = new ValidatorResult();

            //个数为0或者全部通过验证的时候
            if (validators.Length == 0 || validators.All(validator => (result = validator.Validate(model)) == null))
            {
                return ValidatorResult.Success;
            }

            return result;
        }
    }

 

 

以下是我认为这个框架的好处..

　　这个框架将验证的过程单独提出来.封装成相关的类.  并在全局文件中进行注册.. 这样当程序调用的时候. 无论有多少个.. 都直接进行验证. 并返回验证的结果.. 这样以后添加验证的时候.直接写一个类并实现抽象类Validator的抽象方法. 以及返回相应的类型. 然后注册到全局文件中.. 这样就可以不用改方法的基础上.对程序进行扩展了.

 虽然不是很流弊,但是我感觉用起来的话. 还是比较方便的. 对开发.

 

哪里写的不好.还请多批评啊.. 吸取经验. 3Q. 

 

最后附上源文 件: [ 点啊点.点啊点 ]