C#高级进阶教程_03_特性

字数统计: 3.5k字   |   阅读时长≈ 15分

特性初步认识：

[Obsolete]、[Serializable]等

1. 被废弃的，可以影响编译器的运行！

2. 可以序列化和反序列化，可以影响程序的运行！

MVC [filter]过滤器

ORM [table]、[key]、[display]

WCF

特性初步了解：

1. 中括号声明，每一个特性都可以带来对应的功能。

2. 影响编译器的运行，影响程序运行。

3. 就是一个类，继承自attribute。（直接/间接继承都可以）

4. 一般以Attribute结尾，声明时可以省略掉。

实际上，特性添加后，编译会在元素的内部产生IL,但是我们是没有办法直接使用的，而且在metadata（元数据）里面会有记录。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
[AttributeUsage(AttributeTargets.All,AllowMultiple = true)]                        //AttributeUsage用来修饰特性的特性
//[AttributeUsage(AttributeTargets.All, AllowMultiple = false, Inherited = true)]  //Inherited表示是否可以被继承，默认是true。AllowMultiple 运行多重使用的默认值为false。
public class CustomAttribute : Attribute
{
    public CustomAttribute()
    { }

    public CustomAttribute(int id)
    {
        Console.WriteLine("********************");
    }


    public string Description { get; set; }

    public string Remark = null;

    public void Show()
    {
        Console.WriteLine($"This is {nameof(CustomAttribute)}");
    }
}
1
2
3
4
[Custom]                                                //特性无参数的构造函数
[Custom()]                                              //同样也是特性的无参数的构造函数
[Custom(123), Custom(123, Description = "1234")]        //两个特性修饰
[Custom(123,  Description = "1234", Remark = "2345")]   //其实在实例化一个类，方法不能传入
1
2
3
4
5
6
7
8
9
10
11
12
[CustomAttribute]                                                //特性也可以修饰方法
public void Study()
{
    Console.WriteLine($"这里是{this.Name}跟着Eleven老师学习");
}

[Custom()]
[return: Custom()]                                               //特性也可以修饰返回值
public string Answer([Custom]string name)                        //特性也可以修饰参数
{
    return $"This is {name}";
}

以上为特性的语法。

特性有什么用？特性有什么价值？

特性：是用于在运行时传递程序中的各种元素（比如类、方法、结构、枚举、组建等）的行为信息的声明性标签。

可以通过使用特性想程序添加声明性信息。

一个声明性标签是通过放置在它所应用的元素前面的方括号（[]）来描述的。

特性作用：用于添加元数据，如编译器指令和注释、描述、方法、类等其他信息。

.Net框架提供了两种类型的特性：预定义特性和自定义特性。

预定义特性：

** AttributeUsage **修饰特性的特性

** Conditional **这个预定义特性标记了一个条件方法，其执行依赖于指定的预处理标识符。

** Obsolete **标记了不应被使用的程序实体。（过时的）

在程序运行的过程中能找到特性。

Unity中特性的应用！

特性类似于类的补充。增加类额外的信息和行为！（没有破坏类的封装的前提下，没有修改类）

利用反射找特性

通过反射获取特性的方法

01. 通过反射获取类型，检查该类型有没有被特性（CustomAttribute）修饰。

1
2
3
4
5
6
7
Type type = typeof(Student); //student.GetType();        //01.通过反射获取类型
if (type.IsDefined(typeof(CustomAttribute), true))       //type.IsDefined检查有没有  __性能高相对于（type.GetCustomAttribute）
{
  CustomAttribute attribute = (CustomAttribute)type.GetCustomAttribute(typeof(CustomAttribute), true);//02. 通过反射获取实例.  type.GetCustomAttribute
  Console.WriteLine($"{attribute.Description}_{attribute.Remark}");
  attribute.Show();                                      //03.通过实例调用其方法
}

02. 通过反射获取属性，检查该属性有没有被特性（CustomAttribute）修饰。

1
2
3
4
5
6
7
PropertyInfo property = type.GetProperty("Id");
if (property.IsDefined(typeof(CustomAttribute), true))
{
  CustomAttribute attribute = (CustomAttribute)property.GetCustomAttribute(typeof(CustomAttribute), true);
  Console.WriteLine($"{attribute.Description}_{attribute.Remark}");
  attribute.Show();
}

03. 通过反射获取方法，检查该方法有没有被特性（CustomAttribute）修饰。

1
2
3
4
5
6
7
MethodInfo method = type.GetMethod("Answer");
if (method.IsDefined(typeof(CustomAttribute), true))
{
    CustomAttribute attribute = (CustomAttribute)method.GetCustomAttribute(typeof(CustomAttribute), true);
    Console.WriteLine($"{attribute.Description}_{attribute.Remark}");
    attribute.Show();
}

04. 通过反射获取方法参数，检查该参数有没有被特性（CustomAttribute）修饰。

1
2
3
4
5
6
7
8
MethodInfo method = type.GetMethod("Answer");
ParameterInfo parameter = method.GetParameters()[0];
if (parameter.IsDefined(typeof(CustomAttribute), true))
{
    CustomAttribute attribute = (CustomAttribute)parameter.GetCustomAttribute(typeof(CustomAttribute), true);
    Console.WriteLine($"{attribute.Description}_{attribute.Remark}");
    attribute.Show();
}

05. 通过反射获取方法的返回值，检查该返回值有没有被特性（CustomAttribute）修饰。

1
2
3
4
5
6
7
8
MethodInfo method = type.GetMethod("Answer");
ParameterInfo returnParameter = method.ReturnParameter;
if (returnParameter.IsDefined(typeof(CustomAttribute), true))
{
  CustomAttribute attribute = (CustomAttribute)returnParameter.GetCustomAttribute(typeof(CustomAttribute), true);
  Console.WriteLine($"{attribute.Description}_{attribute.Remark}");
  attribute.Show();
}

总的集合代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public static void Show(Student student)
 {
     
     Type type = typeof(Student); //student.GetType();        //01.通过反射获取类型
     if (type.IsDefined(typeof(CustomAttribute), true))//检查有没有  性能高
     {
         CustomAttribute attribute = (CustomAttribute)type.GetCustomAttribute(typeof(CustomAttribute), true);//02. 通过反射获取实例
         Console.WriteLine($"{attribute.Description}_{attribute.Remark}");
         attribute.Show();                                   //03.通过实例调用其方法
     }

     
     PropertyInfo property = type.GetProperty("Id");
     if (property.IsDefined(typeof(CustomAttribute), true))
     {
         CustomAttribute attribute = (CustomAttribute)property.GetCustomAttribute(typeof(CustomAttribute), true);
         Console.WriteLine($"{attribute.Description}_{attribute.Remark}");
         attribute.Show();
     }

     MethodInfo method = type.GetMethod("Answer");
     if (method.IsDefined(typeof(CustomAttribute), true))
     {
         CustomAttribute attribute = (CustomAttribute)method.GetCustomAttribute(typeof(CustomAttribute), true);
         Console.WriteLine($"{attribute.Description}_{attribute.Remark}");
         attribute.Show();
     }

     ParameterInfo parameter = method.GetParameters()[0];
     if (parameter.IsDefined(typeof(CustomAttribute), true))
     {
         CustomAttribute attribute = (CustomAttribute)parameter.GetCustomAttribute(typeof(CustomAttribute), true);
         Console.WriteLine($"{attribute.Description}_{attribute.Remark}");
         attribute.Show();
     }

     ParameterInfo returnParameter = method.ReturnParameter;
     if (returnParameter.IsDefined(typeof(CustomAttribute), true))
     {
         CustomAttribute attribute = (CustomAttribute)returnParameter.GetCustomAttribute(typeof(CustomAttribute), true);
         Console.WriteLine($"{attribute.Description}_{attribute.Remark}");
         attribute.Show();
     }
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
[AttributeUsage(AttributeTargets.All,AllowMultiple = true)]                 //AttributeUsage用来修饰特性的特性
//[AttributeUsage(AttributeTargets.All, AllowMultiple = false, Inherited = true)]  //Inherited表示是否可以被继承，默认是true
public class CustomAttribute : Attribute
{
    public CustomAttribute()
    { }

    public CustomAttribute(int id)
    {
        Console.WriteLine("********************");
    }


    public string Description { get; set; }

    public string Remark = null;

    public void Show()
    {
        Console.WriteLine($"This is {nameof(CustomAttribute)}");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
[Custom(123,  Description = "1234", Remark = "2345")]     
public class Student
{
   [CustomAttribute]
   public int Id { get; set; }
   [Leng(5,10)]//还有各种检查
   public string Name { get; set; } 
   [Leng(20, 50)]
   public string Accont { get; set; }
   [CustomAttribute]
   public void Study()
   {
       Console.WriteLine($"这里是{this.Name}跟着梁老师学习");
   }
   [Custom()]
   [return: Custom()]
   public string Answer([Custom]string name)
   {
       return $"This is {name}";
   }
}

任何一个生效的特性，都是有地方使用了他。

特性的应用场景：

01、给枚举项加一个描述。

02、实体类的属性也可以Display。

03、别名，有特性以特性名称为准，没有特性以枚举类型名称为准。 这种形式称之为映射。

04、做数据检查（可以写在数据库保存之前，或保存方法中）

05、假如属性很多，尝试反射+特性使用

框架的思想

应用场景01: 枚举的应用

** **根据不同的枚举值，触发不同的逻辑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public enum UserState                            //用户状态
{
    /// <summary>
    /// 正常
    /// </summary>
    Normal = 0,//            左边是字段名称，右边是数据库值           哪里放中文描述的问题？  
    /// <summary>
    /// 冻结
    /// </summary>
    Frozen = 1,
    /// <summary>
    /// 删除
    /// </summary>
    Deleted = 2
}
1
2
3
4
5
6
7
8
9
UserState userState = UserState.Normal;
if (userState == UserState.Normal)
{
  Console.WriteLine("正常状态");
}
else if (userState == UserState.Frozen)
{ }
else
{ }

原来的书写方式，也能解决问题，但是不太推荐。

1
2
3
4
5
6
public enum UserState                            //用户状态
{
   正常=0,
   冻结=1，
   删除=2
}
1
2
3
4
5
6
7
8
9
10
11
12
13
UserState userState = UserState.Normal;
if (userState == UserState.正常)
{
  Console.WriteLine("正常状态");
}
else if (userState == UserState.冻结)
{ 
  Console.WriteLine("冻结状态");
}
else
{ 
  Console.WriteLine("删除状态");
}

应该用更高级的写法，应该用特性：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public enum UserState
{
  /// <summary>
  /// 正常
  /// </summary>
  [Remark("正常")]
  Normal = 0,//左边是字段名称  右边是数据库值   哪里放描述？  注释
  /// <summary>
  /// 冻结
  /// </summary>
  [Remark("冻结")]
  Frozen = 1,
  /// <summary>
  /// 删除
  /// </summary>
  [Remark("删除")]
  Deleted = 2
}
1
2
3
4
5
6
7
8
9
10
11
12
public class RemarkAttribute : Attribute
{
  private string _Remark = null;
  public RemarkAttribute(string remark)  //构造函数
  {
      this._Remark = remark;
  }
  public string GetRemark()              //获取方法
  {
      return this._Remark;
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static class RemarkExtension
{
  public static string GetRemark(this Enum value)                  // 扩展方法的使用：
                                                                                    //01.静态类的静态方法
                                                                                    //02.同一命名空间下，Enum类型的调用此方法。 
                                                                                    //03.this关键字的使用
  {
    Type type = value.GetType();                                   // 通过反射获取类型
    FieldInfo field = type.GetField(value.ToString());             // 通过反射获取到枚举类型的字段(MyAttribute.Extension(命名空间).UserState（枚举） Normal（字符串信息）)
    if (field.IsDefined(typeof(RemarkAttribute), true))            // 检查枚举类型的字段有没有被特性修饰
    {
        //利用反射通过字段获取到修饰字段的特性
        RemarkAttribute attribute = (RemarkAttribute)field.GetCustomAttribute(typeof(RemarkAttribute), true);
        return attribute.GetRemark();                             // 返回特性中的方法
    }
    else
    {
        return value.ToString();                                  // 返回枚举类型转成字符串的值
    }
  }
}
1
2
3
UserState userState = UserState.Normal;
Console.WriteLine(RemarkExtension.GetRemark(userState));      //原来的方式调用，常规的使用方法
Console.WriteLine(userState.GetRemark());                     //调用扩展方法，引用命名空间，对应类型的调用此方法

进一步优化，得到

1
2
Console.WriteLine(UserState.Frozen.GetRemark());
Console.WriteLine(UserState.Deleted.GetRemark());

代码里书写是英文，（打印出来显示）或逻辑前端需要显示的是中文。

应用场景归纳：

实质：给枚举项加一个描述。书写了一个规则！

01. 实体类的属性也同样可以！Display的应用。MVC中语法已经支持了！

02. 数据库查询一个列表，列名称（ID/账号/密码/登录时间）（name/pwd/dataTime/… …）

03. 别名，映射！

类似于类的补充，添加一些额外的行为！

做数据检查（可以写在数据库保存之前，保存方法里面也可） ****

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Student
{
  [CustomAttribute]
  public int Id { get; set; }
  [Leng(5,10)]//还有各种检查
  public string Name { get; set; } 
  [Leng(20, 50)]
  public string Accont { get; set; }

  /// <summary>
  /// 10001~999999999999
  /// </summary>
  [Long(10001, 999999999999)]
  public long QQ { get; set; }
}

QQ的限制范围，曾经的方式：

1
2
3
4
5
6
7
8
if (student.QQ > 10001 && student.QQ < 999999999999)
{
  
}
else
{

}

解决数据合法性的问题，数据的检查，重复性比较高！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
private long _QQ2 = 0;                                         //解决数据合法性，但是给属性增加了太多的事儿，后面更改容易抛出异常！
public long QQ2
{
  get
  {
    return this._QQ2;
  }
  set
  {
    if (value > 10001 && value < 999999999999)
    {
        _QQ2 = value;
    }
    else
    {
        throw new Exception();//异常报错信息！
    }
  }
}

实体映射数据库！逻辑单一性原则！

1. 首先自定义一个特性

1
2
3
4
public abstract class AbstractValidateAttribute : Attribute                //抽象类
{
    public abstract bool Validate(object value);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class LongAttribute : AbstractValidateAttribute
{
  private long _Min = 0;
  private long _Max = 0;
  public LongAttribute(long min, long max)
  {
      this._Min = min;
      this._Max = max;
  }
  
  public override bool Validate(object value)//" "                        //重写方法
  {
    //可以改成一句话
    if (value != null && !string.IsNullOrWhiteSpace(value.ToString()))  //值不能为空，ToString（）转成字符串后也不能为空。
    {
        if (long.TryParse(value.ToString(), out long lResult))          //if((,out ))的使用，//如果成功的话，将值赋给lResult，如果不成功则不进行里面的操作。
        {
            if (lResult > this._Min && lResult < this._Max)
            {
                return true;
            }
        }
    }
    return false;                                                       //任何不对，都返回false
}
1
2
3
4
5
public class Student
{
  [Long(10001, 999999999999)]                                             //特性的本质是一个类，所以要记得引入命名空间。
  public long QQ { get; set; }
}

** 验证的拓展类 **

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public static class ValidateExtension
{
  //校验拓展类，最好后期使用泛型，目前使用的是object
  public static bool Validate(this object oObject)
  {
    Type type = oObject.GetType();                                             // 通过反射，找到类型
    foreach (var prop in type.GetProperties())                                 // 通过反射，获取类型的全部属性
    {
      //遍历所有属性是有LongAttribute特性修饰
      if (prop.IsDefined(typeof(LongAttribute), true))                         // 通过反射，检查属性是否有自定义特性LongAttribute修饰
      {
        LongAttribute attribute = (LongAttribute)prop.GetCustomAttribute(typeof(LongAttribute), true);
        if (!attribute.Validate(prop.GetValue(oObject)))                          
        {
            return false;
        }
      }
      
      
      //遍历所有属性是有LengAttribute特性修饰
      if (prop.IsDefined(typeof(LengAttribute), true))
      {
        LengAttribute attribute = (LengAttribute)prop.GetCustomAttribute(typeof(LengAttribute), true);
        if (!attribute.Validate(prop.GetValue(oObject)))
        {
            return false;
        }
      }
    }
    return true;                                                              // 如果有LongAttribute或LengAttribute修饰，则返回true
  }
}

进一步深入拓展可用改造成

1
2
3
4
public abstract class AbstractValidateAttribute : Attribute                //抽象类
{
    public abstract bool Validate(object value);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]      //自定义特性的特性修饰
public class LengAttribute : AbstractValidateAttribute                    //继承抽象类，重写方法，来具体实现
{
  private int _Min = 0;
  private int _Max = 0;
  public LengAttribute(int min, int max)
  {
    this._Min = min;
    this._Max = max;
  }
  public override bool Validate(object value)//" "
  {
    if (value != null && !string.IsNullOrWhiteSpace(value.ToString()))
    {
      int length = value.ToString().Length;
      if (length > this._Min && length < this._Max)
      {
          return true;
      }
    }
    return false;
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class LongAttribute : AbstractValidateAttribute                    //继承抽象类，重写方法，来具体实现
{
  private long _Min = 0;
  private long _Max = 0;
  public LongAttribute(long min, long max)
  {
    this._Min = min;
    this._Max = max;
  }
  public override bool Validate(object value)//" "
  {
    //可以改成一句话
    if (value != null && !string.IsNullOrWhiteSpace(value.ToString()))
    {
      if (long.TryParse(value.ToString(), out long lResult))             //如果成功的话，将值赋给lResult，如果不成功则不进行里面的操作
      {
        if (lResult > this._Min && lResult < this._Max)
        {
            return true;
        }
      }
    }
    return false;
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public static class ValidateExtension                                          //改造后的验证拓展类，只要验证的特性基于AbstractValidateAttribute（抽象验证特性类），那么这个ValidateExtension则不需要更改了。
{
  //校验拓展类，最好后期使用泛型，目前使用的是object
  public static bool Validate(this object oObject)
  {
    Type type = oObject.GetType();                                             //找到类型
    foreach (var prop in type.GetProperties())                                 //获取类型的全部属性
    {
      if (prop.IsDefined(typeof(AbstractValidateAttribute), true))             //校验属性是否有特性
      {
       object[] attributeArray = prop.GetCustomAttributes(typeof(AbstractValidateAttribute), true); //得到自定义的特性数组
       foreach (AbstractValidateAttribute attribute in attributeArray)         //将每个特性转成抽象的验证特性                 
       {
        if (!attribute.Validate(prop.GetValue(oObject)))                       //这个的使用？（直接又调用抽象特性的方法）
        {
          return false;                                                        //表示终止，逻辑思维：一旦遇到一个错误直接结束！
        }
       }
      }
    }
  }
    return true;
}
1
2
3
4
5
6
7
public class Manager
{
  public static void Show(Student student)
  {
    student.Validate();//调用的是拓展方法，使用时要记得要引入ValidateExtension类所在的命名空间。
  }
}

抽象类/继承/具体实现，具体的使用方式。需要深入拓展一下！

特性和配置文件很像！方便维护！

作业练习：

···数据库映射/泛型的数据库访问方法。

···合理自定义接口并使用。

···异常处理/调试技巧等。

···自定义封装框架。

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
三维数字孪生、虚拟仿真
三维平台数据展示、VR沉浸式开发、党建360/720全景开发

联系QQ:2583493258

很惭愧

只做了一点微小的工作
谢谢大家