SRP Single Responsibility Principle 单一职责原则(站在服务提供者的角度来看）
ISP Interface Segregation Principle 接口隔离原则(站在服务调用者的角度来看）：把本质不同的接口隔离开，服务调用者不会多要。
胖接口ITank,违反了接口隔离原则

  1. using System;
  2. namespace ISP_InterfaceSegregationPrinciple_
  3. {
  4.     class Program
  5.     {
  6.         static void Main(string[] args)
  7.         {
  8.             var driver = new Driver(new Car());
  9.             driver.Drive();
  10.         }
  11.     }
  13.     class Driver
  14.     {
  15.         private IVehicle _vehicle;
  16.         public Driver(IVehicle vehicle)
  17.         {
  18.             _vehicle = vehicle;
  19.         }
  21.         public void Drive()
  22.         {
  23.             _vehicle.Run();
  24.         }
  25.     }
  27.     interface IVehicle
  28.     {
  29.         void Run();
  30.     }
  32.     class Car : IVehicle
  33.     {
  34.         public void Run()
  35.         {
  36.             Console.WriteLine("Car is runnning");
  37.         }
  38.     }
  40.     class Truck : IVehicle
  41.     {
  42.         public void Run()
  43.         {
  44.             Console.WriteLine("Truck is runnning");
  45.         }
  46.     }
  48.     interface ITank //胖接口
  49.     {
  50.         void Fire(); //隶属于武器
  51.         void Run(); //隶属于机动车辆
  52.     }
  54.     class LightTank : ITank
  55.     {
  56.         public void Fire()
  57.         {
  58.             Console.WriteLine("Boom");
  59.         }
  61.         public void Run()
  62.         {
  63.             Console.WriteLine("Ka ka ka...");
  64.         }
  65.     }
  67.     class MediumTank : ITank
  68.     {
  69.         public void Fire()
  70.         {
  71.             Console.WriteLine("Medium Boom");
  72.         }
  74.         public void Run()
  75.         {
  76.             Console.WriteLine("Ka!ka! ka!...");
  77.         }
  78.     }
  80.     class HeavyTank : ITank
  81.     {
  82.         public void Fire()
  83.         {
  84.             Console.WriteLine("Heavy Boom");
  85.         }
  87.         public void Run()
  88.         {
  89.             Console.WriteLine("Ka!! ka!! ka!!...");
  90.         }
  91.     }
  92. }

重构：实现多个基接口

  1. using System;
  3. namespace ISP_InterfaceSegregationPrinciple_
  4. {
  5.     class Program
  6.     {
  7.         static void Main(string[] args)
  8.         {
  9.             var driver = new Driver(new HeavyTank());
  10.             driver.Drive();
  11.         }
  12.     }
  14.     class Driver
  15.     {
  16.         private IVehicle _vehicle;
  17.         public Driver(IVehicle vehicle)
  18.         {
  19.             _vehicle = vehicle;
  20.         }
  22.         public void Drive()
  23.         {
  24.             _vehicle.Run();
  25.         }
  26.     }
  28.     interface IVehicle
  29.     {
  30.         void Run();
  31.     }
  33.     class Car : IVehicle
  34.     {
  35.         public void Run()
  36.         {
  37.             Console.WriteLine("Car is runnning");
  38.         }
  39.     }
  41.     class Truck : IVehicle
  42.     {
  43.         public void Run()
  44.         {
  45.             Console.WriteLine("Truck is runnning");
  46.         }
  47.     }
  49.     interface IWeapon
  50.     {
  51.         void Fire();
  52.     }
  54.     interface ITank:IWeapon,IVehicle //胖接口
  55.     {
  56.     }
  58.     class LightTank : ITank
  59.     {
  60.         public void Fire()
  61.         {
  62.             Console.WriteLine("Boom");
  63.         }
  65.         public void Run()
  66.         {
  67.             Console.WriteLine("Ka ka ka...");
  68.         }
  69.     }
  71.     class MediumTank : ITank
  72.     {
  73.         public void Fire()
  74.         {
  75.             Console.WriteLine("Medium Boom");
  76.         }
  78.         public void Run()
  79.         {
  80.             Console.WriteLine("Ka!ka! ka!...");
  81.         }
  82.     }
  84.     class HeavyTank : ITank
  85.     {
  86.         public void Fire()
  87.         {
  88.             Console.WriteLine("Heavy Boom");
  89.         }
  91.         public void Run()
  92.         {
  93.             Console.WriteLine("Ka!! ka!! ka!!...");
  94.         }
  95.     }
  96. }

1 显示接口实现

1.1 隐式实现

  1. using System;
  3. namespace IspExample
  4. {
  5.     class Program
  6.     {
  7.         static void Main(string[] args)
  8.         {
  9.             var Albert = new WarmKiller();
  10.             Albert.Kill();
  11.             Albert.Love();//两个方法都能被看见，不符合现实世界中的逻辑
  12.         }
  13.     }
  15.     interface IGentleman
  16.     {
  17.         void Love();
  18.     }
  20.     interface IKiller
  21.     {
  22.         void Kill();
  23.     }
  25.     class WarmKiller : IGentleman,IKiller
  26.     {
  27.         public void Kill()
  28.         {
  29.             Console.WriteLine("Let me kill the enemy..");
  30.         }
  32.         public void Love()
  33.         {
  34.             Console.WriteLine("i will love you for ever..");
  35.         }
  36.     }
  37. }

1.2 显示实现

  1. using System;
  3. namespace IspExample
  4. {
  5.     class Program
  6.     {
  7.         static void Main(string[] args)
  8.         {
  9.             var Albert = new WarmKiller();          
  10.             Albert.Love();//只能看见Love
  11.             IKiller killer = Albert;
  12.             killer.Kill();//只能看见Kill,两种方法：强制类型转换，as
  13.             var wk = (IGentleman)killer;
  14.             wk.Love();
  15.         }
  16.     }
  18.     interface IGentleman
  19.     {
  20.         void Love();
  21.     }
  23.     interface IKiller
  24.     {
  25.         void Kill();
  26.     }
  28.     class WarmKiller : IGentleman,IKiller
  29.     {
  30.         public void Love()
  31.         {
  32.             Console.WriteLine("i will love you for ever..");
  33.         }
  35.         void IKiller.Kill() //显示实现其接口
  36.         {
  37.             Console.WriteLine("Let me kill the enemy..");
  38.         }
  39.     }
  40. }

2 反射(.Net框架特有的功能）Reflection与依赖注入

C#托管类型的语言

  • 反射：以不变应万变（更松的耦合）
  • 反射与接口的结合
  • 反射与特性的结合
  • 依赖注入：此DI非彼DI，但没有彼DI被没有此DI….

反射有什么用：程序的逻辑有时候不是我们写程序的时候能确定的，程序处于动态状态。以不变应万变的能力。

2.1 反射的原理以及与反射相关的重要技能依赖注入

.NETFramework和.NETCore 反射的API不同

反射的实现

  1. using System;
  2. using System.Reflection;
  4. namespace ISP_InterfaceSegregationPrinciple_
  5. {
  6.     class Program
  7.     {
  8.         static void Main(string[] args)
  9.         {
  10.             ITank tank = new HeavyTank();
  11.             // =========反射=========
  12.             var t = tank.GetType(); //获得类型信息
  13.             object o = Activator.CreateInstance(t);//激活创建一个实例，不通过new创建
  14.             MethodInfo fileMi = t.GetMethod("Fire");
  15.             MethodInfo runMi = t.GetMethod("Run"); //获得方法的信息
  16.             fileMi.Invoke(o, null);
  17.             runMi.Invoke(o, null);//方法必须依托一个实例，第二个值为函数的参数
  19.         }
  20.     }
  22.     class Driver
  23.     {
  24.         private IVehicle _vehicle;
  25.         public Driver(IVehicle vehicle)
  26.         {
  27.             _vehicle = vehicle;
  28.         }
  30.         public void Drive()
  31.         {
  32.             _vehicle.Run();
  33.         }
  34.     }
  36.     interface IVehicle
  37.     {
  38.         void Run();
  39.     }
  41.     class Car : IVehicle
  42.     {
  43.         public void Run()
  44.         {
  45.             Console.WriteLine("Car is runnning");
  46.         }
  47.     }
  49.     class Truck : IVehicle
  50.     {
  51.         public void Run()
  52.         {
  53.             Console.WriteLine("Truck is runnning");
  54.         }
  55.     }
  57.     interface IWeapon
  58.     {
  59.         void Fire();
  60.     }
  62.     interface ITank:IWeapon,IVehicle //胖接口
  63.     {
  64.     }
  66.     class LightTank : ITank
  67.     {
  68.         public void Fire()
  69.         {
  70.             Console.WriteLine("Boom");
  71.         }
  73.         public void Run()
  74.         {
  75.             Console.WriteLine("Ka ka ka...");
  76.         }
  77.     }
  79.     class MediumTank : ITank
  80.     {
  81.         public void Fire()
  82.         {
  83.             Console.WriteLine("Medium Boom");
  84.         }
  86.         public void Run()
  87.         {
  88.             Console.WriteLine("Ka!ka! ka!...");
  89.         }
  90.     }
  92.     class HeavyTank : ITank
  93.     {
  94.         public void Fire()
  95.         {
  96.             Console.WriteLine("Heavy Boom");
  97.         }
  99.         public void Run()
  100.         {
  101.             Console.WriteLine("Ka!! ka!! ka!!...");
  102.         }
  103.     }
  104. }

依赖注入Dependency injection（DI)应用

借助依赖注入框架：NuGet Package Manager—Dependency injection—Microsoft.Extensions.DenpendencyInjection.

  1. using System;
  2. using System.Reflection;
  3. using Microsoft.Extensions.DependencyInjection;
  4. namespace ISP_InterfaceSegregationPrinciple_
  5. {
  6.     class Program
  7.     {
  8.         static void Main(string[] args)
  9.         {
  10.             //容器，向容器要的时候new一个还是单例模式给同一个
  11.             var sc = new ServiceCollection();
  12.             sc.AddScoped(typeof(ITank), typeof(HeavyTank));//一对类型放进了容器
  13.             var sp = sc.BuildServiceProvider();
  14.             // ======== 华丽的分割线 =======
  15.             ITank tank = sp.GetService<ITank>();
  16.             tank.Fire();
  17.             tank.Run();
  18.         }
  19.     }
  21.     class Driver
  22.     {
  23.         private IVehicle _vehicle;
  24.         public Driver(IVehicle vehicle)
  25.         {
  26.             _vehicle = vehicle;
  27.         }
  29.         public void Drive()
  30.         {
  31.             _vehicle.Run();
  32.         }
  33.     }
  35.     interface IVehicle
  36.     {
  37.         void Run();
  38.     }
  40.     class Car : IVehicle
  41.     {
  42.         public void Run()
  43.         {
  44.             Console.WriteLine("Car is runnning");
  45.         }
  46.     }
  48.     class Truck : IVehicle
  49.     {
  50.         public void Run()
  51.         {
  52.             Console.WriteLine("Truck is runnning");
  53.         }
  54.     }
  56.     interface IWeapon
  57.     {
  58.         void Fire();
  59.     }
  61.     interface ITank:IWeapon,IVehicle //胖接口
  62.     {
  63.     }
  65.     class LightTank : ITank
  66.     {
  67.         public void Fire()
  68.         {
  69.             Console.WriteLine("Boom");
  70.         }
  72.         public void Run()
  73.         {
  74.             Console.WriteLine("Ka ka ka...");
  75.         }
  76.     }
  78.     class MediumTank : ITank
  79.     {
  80.         public void Fire()
  81.         {
  82.             Console.WriteLine("Medium Boom");
  83.         }
  85.         public void Run()
  86.         {
  87.             Console.WriteLine("Ka!ka! ka!...");
  88.         }
  89.     }
  91.     class HeavyTank : ITank
  92.     {
  93.         public void Fire()
  94.         {
  95.             Console.WriteLine("Heavy Boom");
  96.         }
  98.         public void Run()
  99.         {
  100.             Console.WriteLine("Ka!! ka!! ka!!...");
  101.         }
  102.     }
  103. }

依赖链

注入到构造器中

  1. using System;
  2. using System.Reflection;
  3. using Microsoft.Extensions.DependencyInjection;
  4. namespace ISP_InterfaceSegregationPrinciple_
  5. {
  6.     class Program
  7.     {
  8.         static void Main(string[] args)
  9.         {
  10.             //容器，向容器要的时候new一个还是单例模式给同一个
  11.             var sc = new ServiceCollection();
  12.             sc.AddScoped(typeof(ITank), typeof(HeavyTank));//一对类型放进了容器
  13.             sc.AddScoped(typeof(IVehicle), typeof(Car));//另一对类型放进了容器
  14.             sc.AddScoped<Driver>();//放一个Driver进入到容器中
  15.             var sp = sc.BuildServiceProvider();
  16.             // ======== 华丽的分割线 =======
  17.             ITank tank = sp.GetService<ITank>();
  18.             tank.Fire();
  19.             tank.Run();
  20.             var driver = sp.GetService<Driver>();//找是否有Driver这个实例，找到后继续查找
  21.             //是否有构造器里面需要的IVehicle,有，IVehicle绑定的是Car,则Driver驾驶Car
  22.             driver.Drive();//依赖链
  23.         }
  24.     }
  26.     class Driver
  27.     {
  28.         private IVehicle _vehicle;
  29.         public Driver(IVehicle vehicle)
  30.         {
  31.             _vehicle = vehicle;
  32.         }
  34.         public void Drive()
  35.         {
  36.             _vehicle.Run();
  37.         }
  38.     }
  40.     interface IVehicle
  41.     {
  42.         void Run();
  43.     }
  45.     class Car : IVehicle
  46.     {
  47.         public void Run()
  48.         {
  49.             Console.WriteLine("Car is runnning");
  50.         }
  51.     }
  53.     class Truck : IVehicle
  54.     {
  55.         public void Run()
  56.         {
  57.             Console.WriteLine("Truck is runnning");
  58.         }
  59.     }
  61.     interface IWeapon
  62.     {
  63.         void Fire();
  64.     }
  66.     interface ITank:IWeapon,IVehicle //胖接口
  67.     {
  68.     }
  70.     class LightTank : ITank
  71.     {
  72.         public void Fire()
  73.         {
  74.             Console.WriteLine("Boom");
  75.         }
  77.         public void Run()
  78.         {
  79.             Console.WriteLine("Ka ka ka...");
  80.         }
  81.     }
  83.     class MediumTank : ITank
  84.     {
  85.         public void Fire()
  86.         {
  87.             Console.WriteLine("Medium Boom");
  88.         }
  90.         public void Run()
  91.         {
  92.             Console.WriteLine("Ka!ka! ka!...");
  93.         }
  94.     }
  96.     class HeavyTank : ITank
  97.     {
  98.         public void Fire()
  99.         {
  100.             Console.WriteLine("Heavy Boom");
  101.         }
  103.         public void Run()
  104.         {
  105.             Console.WriteLine("Ka!! ka!! ka!!...");
  106.         }
  107.     }
  108. }

反射—更松的耦合

更松的耦合一般应用在插件式编程。插件：不与主体程序一起编译，但可以与主体程序一起工作的组件，第三方来提供。以主体程序为中心，变成一个生态圈。
SDK里面的API来约束一下开发者，避免犯不必要的错误。

3 特性

特性是一种类，继承自Attribute,提供一些特殊的信息，本身并没有价值，只有在动态编程利用反射的时候才会体现出强大。

3.1 特性的简单使用

这里自定义了TestInfoAttribute特性，修饰了Student类，能够通过student实例通过反射获取到原数据。在编译过程中会有.custom的自定义实例产生，那一串01 00 06…就是“Albert”。不破坏封装，AOP面向切面编程。
image.png
image.png

  1. namespace AttributeExample {
  3.     class Program {      
  4.         static void Main(string[] args) {
  5.             Student student = new Student() { Age = 24, ID = 1 };
  6.             Type type = student.GetType();
  7.             if (type.IsDefined(typeof(TestInfoAttribute), true)) {
  8.                 TestInfoAttribute testInfoAttribute =(TestInfoAttribute) type.GetCustomAttribute(typeof(TestInfoAttribute));
  9.                 testInfoAttribute.PrintTestInfo();
  10.             }
  11.         }
  12.     }
  14.     [TestInfo("Albert")]
  15.     public class Student {
  16.         public int ID { get; set; }
  17.         public int Age { get; set; }
  18.     }
  20.     [AttributeUsage(AttributeTargets.Class)]
  21.     public class TestInfoAttribute : Attribute {
  22.         private string _testInfo;
  23.         public TestInfoAttribute(string testInfo) {
  24.             _testInfo = testInfo;
  25.         }
  26.         public void PrintTestInfo() {
  27.             Console.WriteLine(_testInfo);
  28.         }
  29.     }
  30. }

3.2 Student转换为StudentDTO几种方式

首先是硬编码的方式效率是最高的，但是没办法做成通用的方法，代码后期可维护性和扩展性变低。选择低一点的版本使用，不然可能找不到一些常用的方法。

  • Json序列化、反序列化
  • AutoMapper 类映射
  • 静态字典缓存+表达式目录树
  • 泛型缓存+表达式目录树 ```csharp using Newtonsoft.Json; using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using AutoMapper; using System.Linq.Expressions; using DynamicExpresso; using Gremlin.Net.Process.Traversal;

namespace DTOExample { class Program { public static Dictionary _Dictionary = new Dictionary();

  1.     static void Main(string[] args) {
  2.         Student student = new Student() { Age = 24, ID = 1, Name = "Albert" };
  3.         //FirstMethod 使用Newtonsoft.Json序列号反序列化  此种方法效率很低
  4.         string sStudent = JsonConvert.SerializeObject(student); //先序列化为字符串
  5.         StudentDTO studentDTO = JsonConvert.DeserializeObject<StudentDTO>(sStudent);//反序列化
  6.         //SecondMethod 使用automapper映射 专属的类型映射工具，为ORM而生 效率高
  7.         Mapper.Initialize(x => x.CreateMap<Student, StudentDTO>());
  8.         StudentDTO studentDTO1 = Mapper.Map<Student, StudentDTO>(student);
  9.         //不同名称的映射
  10.         //Mapper.Initialize(config=> {
  11.         //    config.CreateMap<Student, StudentDTO>().
  12.         //    ForMember(dest => dest.DickName, options => options.MapFrom(sou => sou.Name));
  13.         //});
  14.         //StudentDTO studentDTO2 = Mapper.Map<Student, StudentDTO>(student);
  15.         //ThirdMethod 表达式目录树+静态缓存字典
  17.         //表达式目录树+静态字典
  18.         StudentDTO studentDTO3 = Trans<Student, StudentDTO>(student);
  19.         //效率较高，表达式目录树+泛型缓存
  20.         StudentDTO studentDTO4 = ExpressionGenericMapper<Student, StudentDTO>.Trans(student);
  21.     }
  23.     //表达式+静态字典
  24.     public static TOut Trans<TIn,TOut>(TIn tIn) {
  25.         TOut tOut = Activator.CreateInstance<TOut>();
  26.         string key = string.Format("funckey_{0}_{1}", tIn.GetType().Name, tOut.GetType().Name);
  27.         if (!_Dictionary.ContainsKey(key)) {
  28.             ParameterExpression parameterExpression = Expression.Parameter(typeof(TIn), "p");
  29.             List<MemberBinding> memberBindingsList = new List<MemberBinding>();
  30.             foreach (var item in typeof(TOut).GetProperties()) {
  31.                 MemberExpression property = Expression.Property(parameterExpression, typeof(TIn).GetProperty(item.Name));
  32.                 MemberBinding memberBinding = Expression.Bind(item, property);
  33.                 memberBindingsList.Add(memberBinding);
  34.             }
  35.             foreach (var item in typeof(TOut).GetFields()) {
  36.                 MemberExpression filed = Expression.Field(parameterExpression, typeof(TIn).GetField(item.Name));
  37.                 MemberBinding memberBinding = Expression.Bind(item, filed);
  38.                 memberBindingsList.Add(memberBinding);
  39.             }
  40.             MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(TOut)), memberBindingsList.ToArray());
  41.             Expression<Func<TIn, TOut>> lambda = Expression.Lambda<Func<TIn, TOut>>(memberInitExpression, new ParameterExpression[]
  42.                 {
  43.                     parameterExpression
  44.                 });
  45.             Func<TIn, TOut> func = lambda.Compile();
  46.             _Dictionary[key] = func;
  47.         }
  48.         return ((Func<TIn, TOut>)_Dictionary[key]).Invoke(tIn);
  49.     }
  50. }
  52. class Student {
  53.     public int ID { get; set; }
  54.     public string Name { get; set; }
  55.     public int Age { get; set; }
  56.     public void PrintAge() {
  57.         Console.WriteLine(Age);
  58.     }
  59. }
  61. class StudentDTO {
  62.     public int ID { get; set; }
  63.     public string Name { get; set; }
  64.     //public string DickName { get; set; }
  65.     public int Age { get; set; }
  66.     public void PrintAge() {
  67.         Console.WriteLine(Age);
  68.     }
  69. }
  72. //表达式目录树+泛型缓存
  73. public class ExpressionGenericMapper<TIn, TOut> {
  74.     private static Func<TIn, TOut> _FUNC = null;
  75.     static ExpressionGenericMapper() {
  76.         ParameterExpression parameterExpression = Expression.Parameter(typeof(TIn), "p");
  77.         List<MemberBinding> memberBindingsList = new List<MemberBinding>();
  78.         foreach (var item in typeof(TOut).GetProperties()) {
  79.             MemberExpression property = Expression.Property(parameterExpression, typeof(TIn).GetProperty(item.Name));
  80.             MemberBinding memberBinding = Expression.Bind(item, property);
  81.             memberBindingsList.Add(memberBinding);
  82.         }
  83.         foreach (var item in typeof(TOut).GetFields()) {
  84.             MemberExpression property = Expression.Field(parameterExpression, typeof(TIn).GetField(item.Name));
  85.             MemberBinding memberBinding = Expression.Bind(item, property);
  86.             memberBindingsList.Add(memberBinding);
  87.         }
  88.         MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(TOut)), memberBindingsList.ToArray());
  89.         Expression<Func<TIn, TOut>> lambda = Expression.Lambda<Func<TIn, TOut>>(memberInitExpression, new ParameterExpression[]
  90.         {
  91.                 parameterExpression
  92.         });
  93.         _FUNC = lambda.Compile();//拼装是一次性的
  94.     }
  96.     public static TOut Trans(TIn tIn) {
  97.         return _FUNC(tIn);
  98.     }
  99. }

}

  1. <a name="JreM5"></a>
  2. ## 3.3 BS/CS开发 信息校验特性应用
  3. BS-用户提交信息-页面JS检查-提交到后端-后端还得校验一下，前端不可信-入库<br />CS-用户提交信息-后端校验-入库
  4. ```csharp
  5. namespace ExtendMethod {
  6.     class Program {
  7.         static void Main(string[] args) {
  8.             int a = 5;
  9.             int result = a.CalcAdd(5, 5);
  10.             UserModel userModel = new UserModel();
  11.             userModel.Account = "dfa";
  12.             bool valid1 = userModel.Validate<UserModel>(); //扩展方法
  13.             bool valid2 = AttributeExtend.Validate<UserModel>(userModel);
  14.             Console.WriteLine(result);
  15.             Console.WriteLine(valid1);
  16.             Console.WriteLine(valid2);
  17.         }
  19.         //public static string GetName<T>(this T t) where T : MemberInfo {
  20.         //    if (t.IsDefined(typeof(T), true)) {               
  21.         //    }
  22.         //}
  23.     }
  25.     public static class Calc {
  26.         public static int CalcAdd(this int a, int b, int c) {
  27.             return a + b + c;
  28.         }
  29.     }
  31.     public static class AttributeExtend {
  32.         //一个方法完成不同类型的数据校验--泛型方法
  33.         //得想办法知道，要检查的实体有啥属性，属性有啥规则
  34.         //可以检查全部属性、可以为多个类型服务
  35.         public static bool Validate<T>(this T input) {
  36.             Type type = typeof(T);
  38.             foreach (var item in type.GetProperties()) {
  39.                 if (item.IsDefined(typeof(AttributeBase), true)) {
  40.                     object oValue = item.GetValue(input);
  41.                     object[] oAttributeArray = item.GetCustomAttributes(typeof(AttributeBase), true);
  42.                     foreach (AttributeBase attribute in oAttributeArray) {
  43.                         if (attribute.Validate(oValue)) {
  44.                             return false;
  45.                         }
  46.                     }
  47.                 }
  48.             }
  49.             //foreach (var item in type.GetProperties()) {
  50.             //    if (item.IsDefined(typeof(ElevenRequiredAttribute), true)) {
  51.             //        object oValue = item.GetValue(input);//从input实例中获取属性值
  52.             //        ElevenRequiredAttribute el = (ElevenRequiredAttribute)item.GetCustomAttribute(typeof(ElevenLengthAttribute), true);
  53.             //        if (el.Validate()) {
  54.             //            Console.WriteLine("不合法");
  55.             //            return false;
  56.             //        }
  57.             //    }
  59.             //    if (item.IsDefined(typeof(ElevenLengthAttribute), true)) {
  60.             //        object oValue = item.GetValue(input);//从input实例中获取属性值
  61.             //        //可以获取属性item上特性的实例
  62.             //        ElevenLengthAttribute el = (ElevenLengthAttribute)item.GetCustomAttribute(typeof(ElevenLengthAttribute), true);
  63.             //        if (el.Validate()) {
  64.             //            Console.WriteLine("长度不对");
  65.             //            return false;
  66.             //        }
  67.             //    }
  68.             //}
  69.             return true;
  70.         }
  71.     }
  73.     public class UserModel {
  74.         public string ShortName { get; set; }
  75.         [ElevenRequired]
  76.         [ElevenLength(10, 20)]
  77.         public string Account { get; set; }
  78.         public string Password { get; set; }
  79.         public string Email { get; set; }
  80.     }
  82.     /// <summary>
  83.     /// 校验属性的基类
  84.     /// </summary>
  85.     public abstract class AttributeBase : Attribute {
  86.         public abstract bool Validate(object oValue);
  87.     }
  89.     /// <summary>
  90.     /// 非空特性
  91.     /// </summary>
  92.     public class ElevenRequiredAttribute : AttributeBase {
  93.         public override bool Validate(object oValue) {
  94.             if (oValue == null || string.IsNullOrWhiteSpace(oValue.ToString())) {
  95.                 Console.WriteLine("为空");
  96.                 return false;
  97.             }
  98.             else
  99.                 return true;
  100.         }
  101.     }
  103.     public class ElevenLengthAttribute : AttributeBase {
  104.         private int _Min = 0;
  105.         private int _Max = 0;
  106.         public ElevenLengthAttribute(int min, int max) {
  107.             _Min = min;
  108.             _Max = max;
  109.         }
  111.         public override bool Validate(object oValue) {
  112.             if (oValue.ToString().Length <= _Min && oValue.ToString().Length >= _Max) {
  113.                 Console.WriteLine("长度不对");
  114.                 return false;
  115.             }
  116.             else
  117.                 return true;
  118.         }
  119.     }
  120. }