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

1.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. }

1.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. ## 1.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. }