深刻淺出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] 發送郵件，標明文章位置及用途。轉載時請將此法律聲明一併轉載，謝謝！