深刻浅出Attribute（中）——Attribute本质论

小序：

上篇里，咱们把Attribute“粘”在类的成员方法上show了一把，让Attribute跟你们混了个脸儿熟。中篇里，咱们将探讨“究竟什么是Attribute”和“如何建立及使用Attribute”这两个问题。

准备好了吗？ Let’s go!

正文：

从上篇里咱们能够看到，Attribute彷佛总跟public、static这些关键字（Keyword）出如今一块儿。莫非使用了Attribute就至关于定义了新的修饰符（Modifier）吗？让咱们来一窥究竟！

先把下面这个例子编译出来：

#define OK

using System;
using System.Diagnostics;

namespace Sample
{
         class Program
         {
                   [Conditional("OK")]
                   public static void TargetMethod()
                   {
                            Console.ForegroundColor = ConsoleColor.Green;
                            Console.WriteLine("\t=< 水之真谛>=\nhttp://blog.csdn.net/FantasiaX\n\n" );
                   }
                   static void Main(string[] args)
                   {
                            TargetMethod();
                   }
         }
}

毋庸置疑，它的运行结果会是这样：

接下来，让咱们把编译出的结果（.EXE文件）用“微软中间语言反编译器”打开，查看存储在程序集（Assembly，这在个例子中就是这个.EXE文件）中的中间语言代码（中间语言也就是咱们常说的通用语言）。

若是你认为反汇编是件很神秘的事情，那你可就错了！比起x86汇编语言来，对.NET程序集的反汇编要简单得多——甚至能够说是与C#语言一一对应：

严格地来讲，用来造成上图中树状结构的代码并非程序集中的中间语言，而主要是元数据（Metadata）的功劳。包含在程序集中的元数据记录了这个程序集里有多少个namespace、多少个类、类里有什么成员、成员的访问级别是什么……并且，元数据是以文本（也就是Unicode字符）形式存在的，使用.NET的反射（Reflection）技术，很容易就能把它们读取出来并造成各类各样的漂亮视图——上面的树状图、VS里的Object Browser视图和自动代码提示功能，都是元数据与反射技术结合的产物。一个程序集（.EXE或.DLL）可以使用包含在本身体内的元数据来完整地说明本身，而没必要像C/C++那样带着一大捆头文件，这就叫做“自包含性”或“自描述性”。

扯的有点儿远了——让咱们回到正题，双击反编译器中的TargetMethod:void()。这回弹出窗口里显示的内容是真正的微软中间语言代码了。这些代码也都是文本形式的，须要通过.NET的“虚拟机”再编译后才能被CPU所执行。顺便说一句：VB.NET代码也会编译成这样的中间代码，因此，.NET平台上全部语言的编译结果都是通用的。换句话说，你用C#编写了一个组件，把它编译成一个DLL文件并交给VB.NET程序员，VB.NET程序员能够直接使用，丝绝不必有任何担忧J

今天咱们不打算研究中间语言的编译和执行，主要是打算经过中间语言对一些被C#语言所掩盖的事实一窥究竟。

仔细观察中间代码以后，Attribute变得了无秘密！图中蓝色箭头所指处是两个“真正的”修饰符——Attribute并无出如今这里。而在红色箭头所标识的位置，咱们能够清楚地看出——这分明是在调用mscorlib.dll程序集System.Diagnostics名称空间中ConditionalAttribute类的构造函数。可见，Attribute并非修饰符，而是一个有着独特实例化形式的类！

Attribute实例化有什么独特之处呢？仍是让咱们再次观察中间语言代码——它有两个独特之处。

1. 它的实例是使用.custom声明的。查看中间语言语法，你会发现.custom是专门用来声明自定义特性的。

2. 声明的位置是在函数真正的代码（IL_0000:至IL_0014）以前。

God,我怀疑是否是讲的太深了。不要紧，上面关于中间语言的东西你均可以不care，只须要记住一个结论就能够了——咱们已经从“底层”证实了Attribute不是什么“修饰符”，而是一种实例化方式比较特殊的类。

Attribute的实例化

就像牡蛎天生就要吸附在礁石或船底上同样，Attribute的实例一构造出来就必需“粘”在一个什么目标上。

Attribute实例话的语法是至关怪异的，主要体如今如下三点上：

1. 不使用new操做符来产生实例，而是使用在方括号里调用构造函数的来产生实例。

2. 方括号必需紧挨着放置在被附着目标的前面。

3. 由于方括号里空间有限，不能像使用new那样先构造对象后再对对象的属性（Property）一一赋值。所以，对Attribute实例的属性的赋值也都挤在了构造函数的圆括号里L

说实话，写代码的时候对于第1、第2两条适应起来还算容易，第3条写出来怎么看怎么别扭……并且尤为要记着的是：

1. 构造函数的参数是必定要写的——有几个就得写几个——由于你不写的话实例就没法构造出来。

2. 构造函数参数的顺序不能错，这个很容易理解——调用任何一个函数你都不能改变参数的顺序——除非它有相应的重载（Overload）。由于这个顺序的固定的，因此有些书里管这些参数称为“定位参数”，意即“个数和位置固定的参数”。

3. 对Attribute实例的属性的赋值无关紧要——反正它会有一个默认值。并且，先对哪一个属性赋值、后对哪一个属性赋值不受限制。有些书管这些为属性赋值的参数叫“具名参数”——使人匪夷所思。

OK，百闻不如一见，仍是让咱们本身写一个Attribute类来体验一下吧！

本身动手写Attribute

这回咱们抛弃.NET Framework给咱们准备好的各类Attribute，从头写一个全新的Attribute——Oyster。

下面我给出一个完整的小例子：

//======水之真谛 =======//
//    上善若水,润物无声 //
/* [url]http://blog.csdn.net/FantasiaX[/url] */

using System;
namespace OysterAttributeSample
{
         class Oyster: System.Attribute                         // 必需以System.Attribute类为基类
         {
                   // Kind属性，默认值为 null
                   private string kind;
                   public string Kind
                   {
                            get { return kind; }
                            set { kind = value; }
                   }

                   // Age属性，默认值为
                   private uint age;
                   public uint Age
                   {
                            get { return age; }
                            set { age = value; }
                   }

                   // 值为null的string是危险的，因此必需在构造函数中赋值
                   public Oyster(string arg)                                     // 定位参数
                   {
                            this.Kind = arg;
                   }
         }

         [Oyster("Thorny ", Age=3)]    // 3年的多刺牡蛎附着在轮船（这是一个类）上。注意：对属性的赋值是在圆括号里完成的！
         class Ship
         {
                   [Oyster("Saddle")]          // 0 年的鞍形牡蛎附着在船舵（这是一个数据成员）上，Age使用的是默认值，构造函数的参数必需完整
                   public string Rudder;
         }

         class Program
         {
                   static void Main(string[] args)
                   {
                            // ... 使用反射来读取 Attribute
                   }
         }
}

为了避免把代码拖的太长，上面这个例子中Oyster类的构造函数只有一个参数，因此对“定位参数”体现的还不够淋漓尽致。你们能够再为Oyster类添加几个属性，并在构造函数里多设置几个参数，体验一下Attribute实例化时对参数个数及参数位置的敏感性。

能被Attribute所附着的目标

让咱们思考这样一个问题：牡蛎能够附着在船底、礁石上、桥墩上……甚至是别的牡蛎身上，那么Attribute呢？均可以将本身的实例附着在什么目标上呢？

这个问题的答案隐藏在AttributeTargets这个枚举类型里——这个类型的可取值集合为：

=============================================================================

All Assembly Class Constructor

Delegate Enum Event Field

GenericParameter Interface Method Module

Parameter Property ReturnValue Struct

=============================================================================

一共是16个可取值。

不过，上面这张表是按字母顺序排列的，并不表明它们真实值的排列顺序。使用下面这个小程序能够查看每一个枚举值对应的整数值。

// =<水之真谛 >=
// [url]http://blog.csdn.net/FantasiaX[/url]
using System;
namespace AttributeTargetValue
{
         class Program
         {
                   static void Main(string[] args)
                   {
                            Console.WriteLine("Assembly\t\t\t{0}", Convert.ToInt32(AttributeTargets.Assembly));
                            Console.WriteLine("Module\t\t\t\t{0}", Convert.ToInt32(AttributeTargets.Module));
                            Console.WriteLine("Class\t\t\t\t{0}", Convert.ToInt32(AttributeTargets.Class));
                            Console.WriteLine("Struct\t\t\t\t{0}", Convert.ToInt32(AttributeTargets.Struct));
                            Console.WriteLine("Enum\t\t\t\t{0}", Convert.ToInt32(AttributeTargets.Enum));
                            Console.WriteLine("Constructor\t\t\t{0}", Convert.ToInt32(AttributeTargets.Constructor));
                            Console.WriteLine("Method\t\t\t\t{0}", Convert.ToInt32(AttributeTargets.Method));
                            Console.WriteLine("Property\t\t\t{0}", Convert.ToInt32(AttributeTargets.Property));
                            Console.WriteLine("Field\t\t\t\t{0}", Convert.ToInt32(AttributeTargets.Field));
                            Console.WriteLine("Event\t\t\t\t{0}", Convert.ToInt32(AttributeTargets.Event));
                            Console.WriteLine("Interface\t\t\t{0}", Convert.ToInt32(AttributeTargets.Interface));
                            Console.WriteLine("Parameter\t\t\t{0}", Convert.ToInt32(AttributeTargets.Parameter));
                            Console.WriteLine("Delegate\t\t\t{0}", Convert.ToInt32(AttributeTargets.Delegate));
                            Console.WriteLine("ReturnValue\t\t\t{0}", Convert.ToInt32(AttributeTargets.ReturnValue));
                            Console.WriteLine("GenericParameter\t\t{0}", Convert.ToInt32(AttributeTargets.GenericParameter));
                            Console.WriteLine("All\t\t\t\t{0}", Convert.ToInt32(AttributeTargets.All));
                            Console.WriteLine("\n");
                   }
         }
}

程序的运行结果是：

可能出乎你的预料——它们的值并非步长值为1的线性递增。你观察出什么规律来了吗？提醒你一下：从二进制的角度来考虑喔！！

我想你必定发现了规律——除了All的值以外，每一个值的二进制形式中只有一位是“1”，其他位全是“0”。这就是枚举值的另外一种用法——标识位。那么，标识位有什么好处呢？

考虑这样一种状况：咱们的Attribute要求既能附着在类上，又能附着在类的方法上，应该怎么作呢？

咱们知道，C#中有一个操做符“|”（也就是按位求“或”）。有了它，咱们只须要书写

AttributeTargets.Class | AttributeTargets.Method

就能够了。由于这两个枚举值的标识位（也就是那个惟一的“1”）是错开的，因此只须要按位求或就解决问题了。我想，聪明的你必定马上就能解释为何AttributeTargets.All的值是32767了吧:p

OK，了解了这些以后，咱们应该怎样控制一个Attribute的附着目标呢？

默认状况下，当咱们声明并定义一个新Attribute类时，它的可附着目标是AttributeTargets.All。大多数状况下AttributeTargets.All就已经知足需求了，不过，若是你非要对它有所限制，那就要费点儿周折了。

还拿咱们上面建立的OysterAttribute举例——若是你想把它的附着目标限制为只有“类”和“值域”，你就应该这样书写：

         [AttributeUsage(AttributeTargets.Class|AttributeTargets.Field)]
         class Oyster : System.Attribute
         {
                   // OysterAttribute类的具体实现
         }

没想到吧！原来是用Attribute（的实例）附着在Attribute（类）上！原本吗，Attribute的本质就是类，而AttributeTargets.Class 又说明Attribute能够附着在类上，因此，使用Attribute来“修饰”Attribute也就瓜熟蒂落了J

最后，细心的读者可能会问这样两个问题：

1. 若是一个Attribute附着在了某个类上，那么这个Attribute会为会随着继承关系也附着在派生类上呢？

2. 可不能够像多个牡蛎附着在同一艘船上那样，让一个Attribute的多个实例附着在同一个目标上呢？

Very good! 这真是两个好问题！请看下面的代码：

         [AttributeUsage(AttributeTargets.Class | AttributeTargets.Field, Inherited = false, AllowMultiple = true)]
         class Oyster : System.Attribute
         {
                   // OysterAttribute类的具体实现
         }

原来，AttributeUsage这个用来专门修饰Attribute的Attribute除了能够控制修饰目标外，还能决定被它修饰的Attribute是否可以随宿主“遗传”以及是否可使用多个实例来修饰同一个目标！

OK，你们猜一猜，修饰ConditionalAttribute的AttributeUsage会是什么样子呢？

法律声明： 本文章受到知识产权法保护，任何单位或我的若须要转载此文，必需保证文章的完整性（未经做者许可的任何删节或改动将视为侵权行为）。若您须要转载，请务必注明文章出处为 51CTO 以保障网站的权益；请务必注明文章做者为 刘铁猛 （ [url]http://liutiemeng.blog.51cto.com[/url] ），并向 [email]liutm@beyondsoft.com[/email] 发送邮件，标明文章位置及用途。转载时请将此法律声明一并转载，谢谢！