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

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

.....

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

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

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

开始进入正文:

　　我先说使用方法...

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

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

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

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

　　5. 返回值:

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

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

　　6. 结束

　　这个是测试方法...

 1   static void Main(string[] args)
 2         {
 3 
 4             ///这个在全局的地方配置..可以添加多个类型
 5             Validators.AddValidators<int>(typeof(int), new ValidatorByInt1(), new ValidatorByInt2());
 6 
 7             ///进行验证.
 8             int testValue = 1;
 9             ValidatorResult v = Validators.Validate<int>(testValue);
10             Console.WriteLine(" value:{0}; result:{1}", testValue, v == null ? "正确" : v.ErrorMsg);
11 
12             testValue = 100;
13             v = Validators.Validate<int>(testValue);
14             Console.WriteLine(" value:{0}; result:{1}", testValue, v == null ? "正确" : v.ErrorMsg);
15 
16 
17             testValue = -1;
18             v = Validators.Validate<int>(testValue);
19             Console.WriteLine(" value:{0}; result:{1}", testValue, v == null ? "正确" : v.ErrorMsg);
20 
21             Console.ReadKey();
22         }

Main函数.控制台测试程序

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

 1     public class ValidatorByInt1 : Validator<int>
 2     {
 3         public override ValidatorResult Validate(int model)
 4         {
 5             if (model > 10)
 6             {
 7                 return new ValidatorResult() { ErrorCode = 1, ErrorMsg = "必须小于10" };
 8             }
 9 
10             return ValidatorResult.Success;
11         }
12     }
13 
14 
15     public class ValidatorByInt2 : Validator<int>
16     {
17         public override ValidatorResult Validate(int model)
18         {
19             if (model > 0)
20             {
21                 return ValidatorResult.Success;
22             }
23 
24             return new ValidatorResult() { ErrorCode = 1, ErrorMsg = "必须大于0" };
25         }
26     }

自定义的验证器类.可以传入任何类型.

　　以下是程序集的代码

1   /// <summary>
2     /// 验证器接口,提供验证的功能
3     /// </summary>
4     /// <typeparam name="T"></typeparam>
5     public interface IValidator<T>
6     {
7         ValidatorResult Validate(T model);
8     }

验证器接口: IValidator. 定义了Validate方法...

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

这个是实现IValidator接口的抽象类..没有任何实现0.0

 1     /// <summary>
 2     /// 验证结果..
 3     /// </summary>
 4     public class ValidatorResult
 5     {
 6         private int _ErrorCode = 0x0;
 7         private string _ErrorMsg = "";
 8 
 9         /// <summary>
10         /// 表示验证成功.
11         /// </summary>
12         public static readonly ValidatorResult Success;
13 
14         /// <summary>
15         /// 错误编号
16         /// </summary>
17         public virtual int ErrorCode
18         {
19             get { return _ErrorCode; }
20             set { _ErrorCode = value; }
21         }
22 
23         /// <summary>
24         /// 错误信息
25         /// </summary>
26         public virtual string ErrorMsg
27         {
28             get { return _ErrorMsg; }
29             set { _ErrorMsg = value; }
30         }
31 
32         public ValidatorResult()
33             //未知错误
34             : this(0x1, "未知错误")
35         { }
36 
37         public ValidatorResult(int errorCode, string errorMsg)
38         {
39             this._ErrorCode = errorCode;
40             this._ErrorMsg = errorMsg;
41         }
42     }

这个是调用接口后返回值的类型.. 可以自定义其他类型. 因为属性可重写

  1     /// <summary>
  2     /// 验证器. 提供可以注册每个类型对应的验证器集合.以及验证每个验证器并返回验证器的结果.
  3     /// </summary>
  4     public class Validators
  5     {
  6         private static Dictionary<Type, Object> _AllValidator;
  7 
  8         /// <summary>
  9         /// 保存所有的验证器
 10         /// </summary>
 11         private static Dictionary<Type, Object> AllValidator
 12         {
 13             get { return Validators._AllValidator ?? (Validators._AllValidator = new Dictionary<Type, object>()); }
 14         }
 15 
 16         /// <summary>
 17         /// 给某个类型添加验证器.
 18         /// </summary>
 19         /// <typeparam name="T"></typeparam>
 20         /// <param name="type">类型</param>
 21         /// <param name="validators">验证器数组</param>
 22         public static void AddValidators<T>(Type type, params IValidator<T>[] validators)
 23         {
 24             if (AllValidator.Keys.Contains(type))
 25             {
 26                 AllValidator.Add(type, validators);
 27             }
 28             else
 29             {
 30                 AllValidator[type] = validators;
 31             }
 32 
 33         }
 34 
 35         /// <summary>
 36         /// 移除验证器.并返回其验证器
 37         /// </summary>
 38         /// <typeparam name="T"></typeparam>
 39         /// <param name="type">要移除的类型</param>
 40         /// <returns></returns>
 41         public static IValidator<T>[] RemoveValidators<T>(Type type)
 42         {
 43 
 44             IValidator<T>[] value = default(IValidator<T>[]);
 45 
 46             if (AllValidator.Keys.Contains(type))
 47             {
 48                 value = AllValidator[type] as IValidator<T>[];
 49 
 50                 AllValidator.Remove(type);
 51             }
 52 
 53             return value;
 54         }
 55 
 56 
 57         /// <summary>
 58         /// 根据类型.获取其所有的验证器
 59         /// </summary>
 60         /// <typeparam name="T"></typeparam>
 61         /// <param name="type">要获取验证器数组的类型</param>
 62         /// <returns></returns>
 63         public static IValidator<T>[] GetValidators<T>(Type type)
 64         {
 65             if (AllValidator.Keys.Contains(type))
 66             {
 67                 return AllValidator[type] as IValidator<T>[];
 68             }
 69             else
 70             {
 71                 return null;
 72             }
 73         }
 74 
 75         /// <summary>
 76         /// 清空所有验证器
 77         /// </summary>
 78         public static void Clear()
 79         {
 80             _AllValidator = null;
 81         }
 82 
 83 
 84         /// <summary>
 85         /// 对模型进行多个验证
 86         /// </summary>
 87         /// <typeparam name="T">要验证的模型的类型</typeparam>
 88         /// <param name="model">要验证的模型</param>
 89         /// <param name="validators">验证集合...</param>
 90         /// <returns></returns>
 91         public static ValidatorResult Validate<T>(T model)
 92         {
 93             ///获取验证器数组
 94             IValidator<T>[] validators = Validators.GetValidators<T>(model.GetType());
 95 
 96             ValidatorResult result = new ValidatorResult();
 97 
 98             //个数为0或者全部通过验证的时候
 99             if (validators.Length == 0 || validators.All(validator => (result = validator.Validate(model)) == null))
100             {
101                 return ValidatorResult.Success;
102             }
103 
104             return result;
105         }
106     }

这个是核心类了.. 这里面包含了能够定义全局验证器的方法和在程序中进行验证的方法.

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

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

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

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

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

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

推荐阅读