特性

引

先看一个例子：
在VS中添加一个类库项目和一个控制台项目，在控制台项目中编写以下代码。（控制台项目添加类库项目的程序集）

        static void Main(string[] args)
        {
            Assembly assembly = Assembly.GetAssembly(typeof(Class1));
            Console.WriteLine("程序集名称："+assembly.FullName);
            assembly.GetCustomAttributes();
            Console.WriteLine("程序集Title：" + 
assembly.GetCustomAttribute<AssemblyTitleAttribute>().Title);
            Console.WriteLine("程序集描述：" + 
assembly.GetCustomAttribute<AssemblyDescriptionAttribute>().Description);
            Console.WriteLine("程序集公司：" + 
assembly.GetCustomAttribute<AssemblyCompanyAttribute>().Company);
            Console.Read();
        }

其中Class1是类库项目的类。
执行后可以得到该类库项目输出的程序集的信息。例如：

在VS创建类库项目（以及其他的一些项目）时，会添加一个名为“AssemblyInfo.cs”的文件，其中内容如下：

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// 有关程序集的一般信息由以下
// 控制。更改这些特性值可修改
// 与程序集关联的信息。
[assembly: AssemblyTitle("ClassLibrary1")]
[assembly: AssemblyDescription("测试程序集")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("程序开发公司")]
[assembly: AssemblyProduct("ClassLibrary1")]
[assembly: AssemblyCopyright("Copyright ©  2019")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// 将 ComVisible 设置为 false 会使此程序集中的类型
//对 COM 组件不可见。如果需要从 COM 访问此程序集中的类型
//请将此类型的 ComVisible 特性设置为 true。
[assembly: ComVisible(false)]
// 如果此项目向 COM 公开，则下列 GUID 用于类型库的 ID
[assembly: Guid("e15c7334-bcfc-4c09-a0bc-3798f7742fc8")]
// 程序集的版本信息由下列四个值组成: 
//
//      主版本
//      次版本
//      生成号
//      修订号
//
// 可以指定所有值，也可以使用以下所示的 "*" 预置版本号和修订号
//通过使用 "*"，如下所示:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

这个文件并不是某个类文件，而是为程序集添加额外说明信息的文件，其中运用了很多特性——即使用"[]"包括起来的内容。

特性

特性可以可以为程序添加更多的元数据信息。上面的例子中，使用程序集特性为程序集class1添加了标题，程序集描述，创建公司，版权声明等等信息。除此之外，特性还可以用于如：

• 类
• 委托
• 枚举
• 事件
• 字段
• 泛型参数
• 接口
• 方法
• 属性
  ····
  （可以参考AttributeTargets提供的选项）

特性可以作为一种特殊的类来对待，只是特性类统一继承于System.Attribute,使用特性时，通常可以不带Attribute后缀。

一个自定义特性的例子

一个普通的类继承System.Attribute之后，就成为了一个特性类。在命名类名通常会加上Attribute，例如:

      [System.AttributeUsage(AttributeTargets.Property, Inherited = false, 
AllowMultiple = true)]
      sealed class RequiredAttribute : Attribute
    {
        private bool flag;
        public RequiredAttribute(bool flag)
        {
            this.flag = flag;
        }
        public bool Flag
        {
            get { return flag; }
        }
    }

上面的特性Required标记了某个属性是必须的，并且通过AttributeTargets确定了只能用于属性字段。
可以看到：
特性类是密封类；
特性类也有构造器；
其中System.AttributeUsage可以用来限定自定义特性，（相当于特性的特性）

使用特性修饰

如下代码，定义了一个类，并限定某些字段为必须的

    public class FormClass
    {
        [Required(true)]
        public string ID { get; set; }
        [Required(true)]
        public string Name { get; set; }
        public string Birthday { get; set; }
    }

在网页提交表单是通常要做一些验证，常常就有检验字段是否为空的（当然，表单验证通常不会放在后台来做）。对于FormClass,验证其是否符合要求，可以用反射的方法获取所有的属性，获取属性上的特性标记，判断是否符合特性的要求。

  public class Validator<T>
    {
        private T data;
        public Validator(T data){
           this.data = data;
        }
        //是否已经验证
        bool isValidate { get; set; }
        //验证方法
        bool Validate()
        {
            PropertyInfo[] properties = data.GetType().GetProperties();
            foreach (var item in properties)
            {
                RequiredAttribute required = 
item.GetCustomAttribute<RequiredAttribute>();
                if (required!= null&&required.Flag == true && item.GetValue(data) == 
null)
                {
                    return false;
                }
                else
                {
                    continue;
                }
            }
            return true;
        }
    }

特性与反射息息相关，学习特性前，建议学习了解下这篇博客：C# 反射

一、特性直观感受

每一个特性都会带来对应得功能（其实这是个错觉）。

如下图，两个特性使我们经常在开发中见到的，Obsolete 可以影响到编译器发出警告，Serializable 可以序列化和反序列化影响程序运行

二、声明，定义

特性使用中括号声明，特性是一个类且必须直接或者间接继承 Attribute。

看了 Obsolete 与 Serializable 特性使用后，F12 查看一下源码，可以看到这两个特性都是一个类并且继承 Attribute

三、IL 语言特性

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

这里定义了一个 CustomAttribute 特性，且声明到了 Product 类与其成员上，然后进行编译一下
使用反编译工具，在 bin 目录查看程序集（dll or exe），可以看到与我们写得 C# 源代码一样

点开 Product 类，切换到 IL 语言，可一看到其成员，且在 C# 源代码标记过的地方，都编译成了特性的构造函数

四、特性本身无意义

特性本身是没有用没有意义的。这句话，我们从程序运行也可以验证，下面是个一个简单的例子

这里定义了 CustomAttribute ，且在构造函数里面打印了一句话，在实例化对象是会进行提示

public class CustomAttribute: Attribute
{
    public CustomAttribute()
    {
        Console.WriteLine("CustomAttribute 构造函数");
    }
}

再定义一个 Product 类，其被 CustomAttribute 声明

[Custom]
public class Product
{
    [Custom]
    public int Id { get; set; }

    [Custom]
    public int GetId()
    {
        return Id;
    }
}

这里在 Main 函数，对类进行实例化，对属性赋值，且调用方法

static void Main(string[] args)
{
    Product product= new Product() { Id=1};
    Console.WriteLine(product.GetId());

    Console.ReadKey();
}

启动，可以看到，程序正常运行，且没有打印 Custom 特性相关的提示信息，所以特性本身是没有意义的。

五、特性 API

特性本身是没有用的，程序运行过程中，我们能找到特性，而且也能应用一下。特性可以声明在类、方法、字段、属性、参数、返回值上，程序运行时可以获取到特性声明的信息。

首先定义 CustomAttribute 特性，且包含 Desc 属性和两个构造函数

public class CustomAttribute: Attribute 
{
    public string Desc { get; set; }

    public CustomAttribute()
    {
        Console.WriteLine("CustomAttribute 构造函数");
    }

    public CustomAttribute(string desc)
    {
        Console.WriteLine("CustomAttribute 有参构造函数");
        Desc = desc;
    }
}

定义 Product 类，在其本身与成员及方法返回值全部声明 CustomAttribute

[Custom("我在类上")]
public class Product
{
    [Custom("我在字段上")]
    public string name;

    [Custom("我在属性上")]
    public string Name { get; set; }

    [Custom("我在方法上")]
    [return:Custom("我在返回值上")]
    public string GetName([Custom("我在参数上")] int id)
    {
        return Name;
    }
}

在 Main 函数，写了一些特性实例化与获取信息的一些 API

static void Main(string[] args)
{
    Product product= new Product() { };

    Type type = typeof(Product);
    if (type.IsDefined(typeof(CustomAttribute), true))
    {
        CustomAttribute customAttribute = (CustomAttribute)type.GetCustomAttribute(typeof(CustomAttribute),true);
        Console.WriteLine(customAttribute.Desc);
    }

    MethodInfo method = type.GetMethod("GetName");
    if (method.IsDefined(typeof(CustomAttribute), true))
    {
        CustomAttribute customAttribute = (CustomAttribute)method.GetCustomAttribute(typeof(CustomAttribute), true);
        Console.WriteLine(customAttribute.Desc);
    }

    ParameterInfo parameter = method.GetParameters()[0];
    if (parameter.IsDefined(typeof(CustomAttribute), true))
    {
        CustomAttribute customAttribute = (CustomAttribute)parameter.GetCustomAttributes(typeof(CustomAttribute), true)[0];
        Console.WriteLine(customAttribute.Desc);
    }

    ParameterInfo returnParameter = method.ReturnParameter;
    if (returnParameter.IsDefined(typeof(CustomAttribute), true))
    {
        CustomAttribute customAttribute = (CustomAttribute)returnParameter.GetCustomAttribute(typeof(CustomAttribute), true);
        Console.WriteLine(customAttribute.Desc);
    }

    PropertyInfo property = type.GetProperty("Name");
    if (property.IsDefined(typeof(CustomAttribute), true))
    {
        CustomAttribute customAttribute = (CustomAttribute)property.GetCustomAttribute(typeof(CustomAttribute), true);
        Console.WriteLine(customAttribute.Desc);
    }

    FieldInfo field = type.GetField("name");
    if (field.IsDefined(typeof(CustomAttribute), true))
    {
        CustomAttribute customAttribute = (CustomAttribute)field.GetCustomAttribute(typeof(CustomAttribute), true);
        Console.WriteLine(customAttribute.Desc);
    }

    Console.ReadKey();
}

启动，可以看到在成员运行时，拿取到声明特性的各种信息

CustomAttribute customAttribute = (CustomAttribute)field.GetCustomAttribute(typeof(CustomAttribute), true); // 会实例化特性

六、特性实际应用

没有破坏封装的前提下，可以额外的加点消息与行为。

说到这可能有的同学就问，上面说了那么多，在我们平时开发时有什么实际用处吗？答案是：有的，接下来使用实例进行讲解

6.1、添加额外消息

场景：分销系统，订单状态开发时通常喜欢使用枚举进行定义，但在 UI 展示其对于描述时有哪些做法呢？

首先，订单状态枚举定义，这里进行简化

public enum OrderStatus
{
    /// <summary>
    /// 暂存
    /// </summary>
    TemporaryStorage = 0,
    /// <summary>
    /// 未审批
    /// </summary>
    NotApproved = 10,
    /// <summary>
    /// 已审批
    /// </summary>
    Approved = 20

    // 还有其他许多状态，这里不进行举例
}

第一种：手动维护，拼凑（还会有其他类似的写法，这里不进行一一举例）

列表， 这里有的开发时写了一个类似 K-V 的集合，分表对值与描述进行了，平凑返回给 UI ，进行渲染 select 或者 list

public static Dictionary<int, string> GetOrderStatusList()
{
    Dictionary<int, string> orderStatus = new Dictionary<int, string>();
    orderStatus.Add(OrderStatus.Approved.GetHashCode(), "暂存");
    orderStatus.Add(OrderStatus.Approved.GetHashCode(), "未审批");
    orderStatus.Add(OrderStatus.Approved.GetHashCode(), "已审批");
    // 未来扩展状态流，都得手动进行添加

    return orderStatus;
}

表单，面对数据报表，单个状态对于的描述，通常使用一串的 if 进行获取

public static string GetOrderStatusRemark(OrderStatus orderStatus)
{
    if (orderStatus == OrderStatus.Approved)
    {
        return "暂存";
    }
    else if(orderStatus == OrderStatus.Approved)
    {
        return "已审批";
    }
    else if (orderStatus == OrderStatus.NotApproved)
    {
        return "未审批";
    }
    // 未来扩展状态流，都得手动进行添加

    return orderStatus.ToString();
}

特性方式：提高开发效率，且公用，易于维护，易于编码

首先定义一个 RemarkAttribute 特性，使用 _Remark 承载我们的描述信息

public class RemarkAttribute : Attribute
{
    private string _Remark { get; set; }

    public RemarkAttribute(string remark)
    {
        _Remark = remark;
    }

    public string GetRemark()
    {
        return _Remark;
    }
}

在状态枚举成员打上特性，且输入每个状态的描述信息

public enum OrderStatus
{
    /// <summary>
    /// 暂存
    /// </summary>
    [Remark("暂存")]
    TemporaryStorage = 0,
    /// <summary>
    /// 未审批
    /// </summary>
    [Remark("未审批")]
    NotApproved = 10,
    /// <summary>
    /// 已审批
    /// </summary>
    [Remark("已审批")]
    Approved = 20

    // 还有其他许多状态，这里不进行举例
}

创建一个状态枚举的扩张类，写一个 GetRemark 扩张方法，用于取当前状态成员标记特性的描述信息

public static class OrderStatusExtension
{
    public static string GetRemark(this OrderStatus val)
    {
        Type type = val.GetType();
        FieldInfo field = type.GetField(val.ToString());
        if (field.IsDefined(typeof(RemarkAttribute),true))
        {
            RemarkAttribute remarkAttribute = (RemarkAttribute)field.GetCustomAttribute(typeof(RemarkAttribute), true);
            return remarkAttribute.GetRemark();
        }
        return val.ToString();
    }
}

启动，可以看到，成功从 Remark 特性成员 _Remark 字段获取到 NotApproved 状态的描述信息

static void Main(string[] args)
{

    OrderStatus orderStatus = OrderStatus.NotApproved;
    Console.WriteLine(orderStatus.GetRemark());

    Console.ReadKey();
}

延展：平时开发程序，model 对于的表格或者表单的描述也可用此方法

6.2、添加额外行为

场景：表单提交，数据效验

public class Personal
{
    public string Name { get; set; }

    public string Address { get; set; }

    public long  QQ { get; set; }

    // 还有许多其他字段
}

第一种：这种写法最简单的，通常在 mvc 的 action 方法里面进行效验，在多个 action 中这种会造成代码重复，且维护困难

Personal personal= new Personal() { QQ = 1};
if (personal.QQ > 10001 && personal.QQ < 999999999999)
{

}
 // 还有更多 else if () 对其他进行效验
 

第二种：由于第一种产生的问题，有的小伙伴会将验证逻辑放到 get set 访问器中，这种造成了职责不分明，实体本身是承载信息的，不需要存在业务逻辑

public class Personal
{
    public string Name { get; set; }

    public string Address { get; set; }

    public long QQ
    {
        get
        {

            return this.QQ;
        }
        set
        {
            if (value > 10001 && value < 999999999999)
            {
                this.QQ = value;
            }
            else
            {
                throw new Exception("QQ号不合法");
            }
        }
    }

    // 还有许多其他字段
}

特性方式：由于以上两种产生的问题，我们可以使用特性进行处理，易于维护、易于编码、易于公用

定义一个 LongAttribute 特性，其中有个最小、最大字段，且有一个 Validate 方法用于处理效验逻辑

public class LongAttribute : Attribute
{
    private long _Min { get; set; }
    private long _Max { get; set; }

    public LongAttribute(long min,long max)
    {
        _Min = min;
        _Max = max;
    }

    public bool Validate(object val)
    {
        if (val != null && !string.IsNullOrEmpty(val.ToString()))
        {
            if (long.TryParse(val.ToString(),out long lResult))
            {
                if (lResult > _Min && lResult < _Max)
                {
                    return true;
                }
            }
        }
        return false;
    }
}

定义一个实体类，有 Name、Address 、QQ 三个字段（实际比这多），在 QQ 字段标记特性 Long 并定义 min max

public class Personal
{
    public string Name { get; set; }

    public string Address { get; set; }

    [Long(1001, 99999999999)]
    public long QQ { get; set; }

    // 还有许多其他字段
}

定义一个 Validate 的扩张类与扩张方法，其作用是取得对象 Type 获取 LongAttribute 并调用其 Validate 进行业务逻辑效验

public static class ValidateExtension
{
    public static bool Validate(this object val)
    {
        Type type= val.GetType();
        foreach (var prop in type.GetProperties())
        {
            if (prop.IsDefined(typeof(LongAttribute),true))
            {
                LongAttribute longAttribute = (LongAttribute)prop.GetCustomAttribute(typeof(LongAttribute),true);
                if(!longAttribute.Validate(prop.GetValue(val)))
                {
                	return  false;
                }            
             }
        }
        return true;
    }
}

这里，分别实例化两个 Personal ，并对 QQ 字段赋予不合法与合法的值

static void Main(string[] args)
{
    Personal personal= new Personal() { QQ = 1};
    Console.WriteLine(personal.Validate());
    
    Personal personal1= new Personal() { QQ = 100000};
    Console.WriteLine(personal1.Validate());

    Console.ReadKey();
}

启动，可以看到对效验的结果，分别返回了 false true 成功的进行了效验

有人要问只验证个 QQ 有啥意义？且慢，我们还可以多名字等其他字段进行验证，接着我们对 name 字段进行效验

定义一个 LengthAttribute 特性，定义 min max 两个成员，Validate 方法进行业务逻辑效验

public class LengthAttribute : Attribute
{
    private long _Min { get; set; }
    private long _Max { get; set; }

    public LengthAttribute(long min, long max)
    {
        _Min = min;
        _Max = max;
    }

    public bool Validate(object val)
    {
        if (val != null && !string.IsNullOrEmpty(val.ToString()))
        {
            if (val.ToString().Length > _Min && val.ToString().Length < _Max)
            {
                return true;
            }
        }
        return false;
    }
}

在 name 字段打上 Length 特性，且定义 min = 1，max =10

public class Personal
{
    [Length(1, 10)]
    public string Name { get; set; }

    public string Address { get; set; }

    [Long(1001, 99999999999)]
    public long QQ { get; set; }

    // 还有许多其他字段
}

在 ValidateExtension 类 Validate 方法添加一个 LengthAttribute 特性的检查

public static class ValidateExtension
{
    public static bool Validate(this object val)
    {
        Type type= val.GetType();
        foreach (var prop in type.GetProperties())
        {
            if (prop.IsDefined(typeof(LongAttribute),true))
            {
                LongAttribute longAttribute = (LongAttribute)prop.GetCustomAttribute(typeof(LongAttribute),true);
                if(!longAttribute.Validate(prop.GetValue(val)))
                {
                	return false;
                }
            }
            if (prop.IsDefined(typeof(LengthAttribute), true))
            {
                LengthAttribute longAttribute = (LengthAttribute)prop.GetCustomAttribute(typeof(LengthAttribute), true);
                if(!longAttribute.Validate(prop.GetValue(val)))
                {
                	return false;
                }
            }
        }
        return true;
    }
}

实例化 Personal ，对 name 字段进行赋值

static void Main(string[] args)
{

    Personal personal= new Personal() { Name = "张三"};
    Console.WriteLine(personal.Validate());

    Personal personal1= new Personal() { Name = "张"};
    Console.WriteLine(personal1.Validate());

    Console.ReadKey();
}

启动，可以看到，根据标记的特性正确的进行了检测

抽象

public class AbstractValidateAttribute : Attribute
{
    public virtual bool Validate(object val) => false;
}

public class LongAttribute : AbstractValidateAttribute
{
    private long _Min { get; set; }
    private long _Max { get; set; }

    public LongAttribute(long min, long max)
        {
            _Min = min;
            _Max = max;
        }

    public override bool Validate(object val)
        {
            if (val != null && !string.IsNullOrEmpty(val.ToString()))
            {
                if (long.TryParse(val.ToString(), out long lResult))
                {
                    if (lResult > _Min && lResult < _Max)
                    {
                        return true;
                    }
                }
            }
            return false;
        }
}



public class LengthAttribute : AbstractValidateAttribute
{
    private long _Min { get; set; }
    private long _Max { get; set; }

    public LengthAttribute(long min, long max)
        {
            _Min = min;
            _Max = max;
        }

    public override bool Validate(object val)
    {
        if (val != null && !string.IsNullOrEmpty(val.ToString()))
        {
            if (val.ToString().Length > _Min && val.ToString().Length < _Max)
            {
                return true;
            }
        }
        return false;
    }
}

static void Main(string[] args)
{
    Personal personal= new Personal() { Name = "张",QQ = 9999999};
    Console.WriteLine(personal.Validate());

    Personal personal1 = new Personal() { Name = "张三", QQ = 1 };
    Console.WriteLine(personal1.Validate());

    Personal personal2 = new Personal() { Name = "张三", QQ = 9999999 };
    Console.WriteLine(personal2.Validate());

    Console.ReadKey();
}

目录

前言

一.预定义的保留特性

1.Obsolete特性

2.Conditional特性

3.CallerFilePath、CallerLineNumber、CallerMemberName

4.DebuggerStepThough

4.其它预定义特性

二.自定义特性

三.访问特性

---

---

前言

特性是一种允许我们向程序的程序集增加元数据的语言结构，它用于保存程序结构信息的某种特殊类型的类。简单的说，特性主要是结合反射来获得程序的某些信息，在一般情况下其实没什么卵用。

特性的使用形式如下：

    [Serializable]   //特性
    public class Myclass  
    {
        ...
    }

    [MyAttribute("Simple class","Version 3.57")] //带有参数的特性
    public class MyOtherClass
    {
        ...
    }

一.预定义的保留特性

1.Obsolete特性

Obsolete特性将程序结构标注为过期的，但是标注的程序依然可以使用，只是用于警告用户尽量使用新的方法。

using System;

namespace AttributeTest
{
    class Program
    {
        static void Main(string[] args)
        {
            PrintOut("Hello World!");
        }


        [Obsolete("这个方法要过期了，请使用SuperPrintOut方法")]
        static void PrintOut(string str)
        {
            Console.WriteLine(str);
        }

        static void SuperPrintOut(string str)
        {
            Console.WriteLine(str ?? "这是一个空字符串！");
        }
    }
}

在Vs中 被[Obsolete]修饰的方法还会给出提示：

 在编译的时候也会给出类似的警告。

2.Conditional特性

Conditional特性类似于条件调用，如果熟悉#if、#endif的话，应该还是很好理解的。不同的是Conditional是对方法本省的修饰，而#if、#endif则是对调用的修饰。看下面的例子：

#define SABER
using System;
using System.Diagnostics;

namespace AttributeTest
{
    class Program
    {
        static void Main(string[] args)
        {
#if TEST
            PrintOut("Hello World!");
#endif
            SuperPrintOut(null);

        }


        [Obsolete("这个方法要过期了，请使用SuperPrintOut方法")]
        static void PrintOut(string str)
        {
            Console.WriteLine(str);
        }


        [Conditional("SABER")]
        static void SuperPrintOut(string str)
        {
            Console.WriteLine(str ?? "这是一个空字符串！");
        }
    }
}

 运行结果如下：

由于我没有预先定义TEST 字符串，因此PrintOut函数不会执行，并且在VS编辑器中

 PrintOut("Hello World!");  //实际显示为灰色

显示为灰色，很明显的告诉我们这一行不执行。而我定义了SABER，因此会执行SuperPrintOut函数。

加入你把SABER的定义去掉，在Main函数中不会有任何变化，但是运行结果不会再出现上面的那行字符串。 

因为[Conditional]主要对方法进行修饰，因此要对方法进行条件调用的时候，建议用[Conditional]修饰而不是#if。且Conditional只能修饰返回值为Void类型的方法。

3.CallerFilePath、CallerLineNumber、CallerMemberName

这三个特性只能用于方法中的可选参数，分别提醒文件路径、代码所在行数、调用成员名称信息。具体的使用方法请参见我之前的博客：C# CallerMemberName特性介绍以及简化InotifyPropertyChanged的实现。

4.DebuggerStepThough

如果你很确定你的某段代码是正确的，在调试是，对其反复单步调试只会徒增时间，那么你可以使用这个特性。该特性是的在单步调试时，不要进入某些方法。

    class SimpleA
    {
        int _x = 1;
        int X
        {
            get => _x;
            [DebuggerStepThrough]  //不进入set访问器
            set
            {
                _x = _x * 2;
                _x += value;
            }            
        }
        public int Y { get; set; }
            
        [DebuggerStepThrough]  //不进入这个方法
        void IncrementFields()
        {
            X++;
            Y++;
        }
        
    }

4.其它预定义特性

.Net框架预定义了很多编译器和CLR能理解和解释的特性，下面给出了一些重要的特性：

一直字段也可以同事被应用多个特性，下面这两种特性使用时等价的：

 

---

二.自定义特性

其实特性只是某个特殊类型的类。要申明一个自定义特性需要：

• 声明一个派生自System.Attribute的类

• 给它取一个以后缀Attribute结尾的名字

 下面时一个特性的声明和使用：

[MyAttribyte("An simple class",reviewe:"QYL",ver:"2.0")]
    class SimpleA
    {
        int _x = 1;
        int X
        {
            get => _x;
            [DebuggerStepThrough]  //不进入set访问器
            set
            {
                _x = _x * 2;
                _x += value;
            }            
        }
        public int Y { get; set; }
            
        [DebuggerStepThrough]  //不进入这个方法
        void IncrementFields()
        {
            X++;
            Y++;
        }
        
    }

    public sealed class MyAttribyteAttribute:System.Attribute
    {
        public string Description;
        public string Version;
        public string Reviewer;

        public MyAttribyteAttribute(string desc)
        {
            Description = desc;
        }
        public MyAttribyteAttribute(string desc,string ver,string reviewe)
        {
            Description = desc;
            Reviewer = reviewe;
            Version = ver;
        }
    }

可以使用AttributeUsage特性来限制自定义特性只能使用在某些目标上，例如一旦限制特性使用在方法上，就不能像上面那样修饰类：

AttributeUsage有三个重要的公共属性：

 

 下面这个特性表示：MyAttribute只能用于类上、MyAttribute不会应用到它的派生类上、不能有MyAttibute的多个实例应用到同一个目标上。

    [AttributeUsage(AttributeTargets.Class,  //必须的，位置参数
        Inherited =false,  //可选的，命名参数)]
        AllowMultiple =false)]  //可选的，命名参数

三.访问特性

我们可以使用Type对象来获取类型信息，对于特性，Type也有2个重要的方法：IsDefined和GetCustomeAttributes。

IsDefined方法用来检测某个特性是否应用到了某个类上。

#define SABER
using System;
using System.Diagnostics;

namespace AttributeTest
{
    class Program
    {
        static void Main(string[] args)
        {

            SimpleA simpleA = new SimpleA();
            Type t = simpleA.GetType();  //从实例中获取类型对象
            bool isDefined = t.IsDefined(typeof(MyAttribyteAttribute), false);
            if (isDefined)
                Console.WriteLine($"MyAttribute is applied to type {t.Name}");

#if TEST
            PrintOut("Hello World!");
#endif
            SuperPrintOut(null);

        }
    }

  class SimpleA
    {
        int _x = 1;
        int X
        {
            get => _x;
            [DebuggerStepThrough]  //不进入set访问器
            set
            {
                _x = _x * 2;
                _x += value;
            }            
        }
        public int Y { get; set; }
            
        [DebuggerStepThrough]  //不进入这个方法
        void IncrementFields()
        {
            X++;
            Y++;
        }
        
    }

    [AttributeUsage(AttributeTargets.Class,  //必须的，位置参数
        Inherited =false,  //可选的，命名参数)]
        AllowMultiple =false)]  //可选的，命名参数
    public sealed class MyAttribyteAttribute:System.Attribute
    {
        public string Description;
        public string Version;
        public string Reviewer;

        public MyAttribyteAttribute(string desc)
        {
            Description = desc;
        }
        public MyAttribyteAttribute(string desc,string ver,string reviewe)
        {
            Description = desc;
            Reviewer = reviewe;
            Version = ver;
        }
    }
}

输出：MyAttribute is applied to type SimpleA

---

GetCustomeAttributes方法返回应用到结构的数组。实际返回的对象是object的数组，因此我们必须将他强制转换为相应的特性类型。布尔参数指定是否继续搜索继承树来查找特性。调用该方法后，每一个与目标相关联的特性的实例都会被创建

object[] attrs=t.GetCustomedAttributes(false)

 对Main函数作修改，使用GetCustomedAttributes函数的示例：

        static void Main(string[] args)
        {

            SimpleA simpleA = new SimpleA();
            Type t = simpleA.GetType();  //从实例中获取类型对象
            bool isDefined = t.IsDefined(typeof(MyAttributeAttribute), false);
            //if (isDefined)
            //    Console.WriteLine($"MyAttribute is applied to type {t.Name}");
            object[] attrs = t.GetCustomAttributes(false);
            foreach(var a in attrs)
            {
                if (a is MyAttributeAttribute myAttribyteAttribute)
                {
                    Console.WriteLine($"Description:  {myAttribyteAttribute.Description}");
                    Console.WriteLine($"Version number:    {myAttribyteAttribute.Version}");
                    Console.WriteLine($"Reviewer ID:     {myAttribyteAttribute.Reviewer}");
                }
            }

#if TEST
            PrintOut("Hello World!");
#endif
            SuperPrintOut(null);

        }

运行结果：

Description:  An simple class
Version number:    2.0
Reviewer ID:     QYL
这是一个空字符串！