上篇里，我們把Attribute“粘”在類的成員方法上show了一把，讓Attribute跟大家混了個臉兒熟。中篇里，我們將探討“究竟什么是Attribute”和“如何創(chuàng)建及使用Attribute”這兩個問題。

正文：

從上篇里我們可以看到，Attribute似乎總跟public、static這些關(guān)鍵字（Keyword）出現(xiàn)在一起。莫非使用了Attribute就相當(dāng)于定義了新的修飾符（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();
                   }
         }
}

毋庸置疑，它的運行結(jié)果會是這樣：

接下來，讓我們把編譯出的結(jié)果（.EXE文件）用“微軟中間語言反編譯器”打開，查看存儲在程序集（Assembly，這在個例子中就是這個.EXE文件）中的中間語言代碼（中間語言也就是我們常說的通用語言）。

如果你認(rèn)為反匯編是件很神秘的事情，那你可就錯了！比起x86匯編語言來，對.NET程序集的反匯編要簡單得多——甚至可以說是與C#語言一一對應(yīng)：

嚴(yán)格地來說，用來形成上圖中樹狀結(jié)構(gòu)的代碼并不是程序集中的中間語言，而主要是元數(shù)據(jù)（Metadata）的功勞。包含在程序集中的元數(shù)據(jù)記錄了這個程序集里有多少個namespace、多少個類、類里有什么成員、成員的訪問級別是什么……而且，元數(shù)據(jù)是以文本（也就是Unicode字符）形式存在的，使用.NET的反射（Reflection）技術(shù)，很容易就能把它們讀取出來并形成各種各樣的漂亮視圖——上面的樹狀圖、VS里的Object Browser視圖和自動代碼提示功能，都是元數(shù)據(jù)與反射技術(shù)結(jié)合的產(chǎn)物。一個程序集（.EXE或.DLL）能夠使用包含在自己體內(nèi)的元數(shù)據(jù)來完整地說明自己，而不必像C/C++那樣帶著一大捆頭文件，這就叫作“自包含性”或“自描述性”。

扯的有點兒遠了——讓我們回到正題，雙擊反編譯器中的TargetMethod:void()。這回彈出窗口里顯示的內(nèi)容是真正的微軟中間語言代碼了。這些代碼也都是文本形式的，需要經(jīng)過.NET的“虛擬機”再編譯后才能被CPU所執(zhí)行。順便說一句：VB.NET代碼也會編譯成這樣的中間代碼，所以，.NET平臺上所有語言的編譯結(jié)果都是通用的。換句話說，你用C#編寫了一個組件，把它編譯成一個DLL文件并交給VB.NET程序員，VB.NET程序員可以直接使用，絲毫不必有任何擔(dān)心J

今天我們不打算研究中間語言的編譯和執(zhí)行，主要是打算通過中間語言對一些被C#語言所掩蓋的事實一窺究竟。 

仔細(xì)觀察中間代碼之后，Attribute變得了無秘密！圖中藍色箭頭所指處是兩個“真正的”修飾符——Attribute并沒有出現(xiàn)在這里。而在紅色箭頭所標(biāo)識的位置，我們可以清楚地看出——這分明是在調(diào)用mscorlib.dll程序集System.Diagnostics名稱空間中ConditionalAttribute類的構(gòu)造函數(shù)。可見，Attribute并不是修飾符，而是一個有著獨特實例化形式的類！

Attribute實例化有什么獨特之處呢？還是讓我們再次觀察中間語言代碼——它有兩個獨特之處。

1. 1.         它的實例是使用.custom聲明的。查看中間語言語法，你會發(fā)現(xiàn).custom是專門用來聲明自定義特性的。
2. 2.         聲明的位置是在函數(shù)真正的代碼（IL_0000:至IL_0014）之前。

God,我懷疑是不是講的太深了。沒關(guān)系，上面關(guān)于中間語言的東西你都可以不care，只需要記住一個結(jié)論就可以了——我們已經(jīng)從“底層”證明了Attribute不是什么“修飾符”，而是一種實例化方式比較特殊的類。

Attribute的實例化

就像牡蠣天生就要吸附在礁石或船底上一樣，Attribute的實例一構(gòu)造出來就必需“粘”在一個什么目標(biāo)上。

Attribute實例話的語法是相當(dāng)怪異的，主要體現(xiàn)在以下三點上：

1. 1.         不使用new操作符來產(chǎn)生實例，而是使用在方括號里調(diào)用構(gòu)造函數(shù)的來產(chǎn)生實例。
2. 2.         方括號必需緊挨著放置在被附著目標(biāo)的前面。
3. 3.         因為方括號里空間有限，不能像使用new那樣先構(gòu)造對象后再對對象的屬性（Property）一一賦值。因此，對Attribute實例的屬性的賦值也都擠在了構(gòu)造函數(shù)的圓括號里，說實話，寫代碼的時候?qū)τ诘?、第2兩條適應(yīng)起來還算容易，第3條寫出來怎么看怎么別扭……而且尤其要記著的是：
4. 1.         構(gòu)造函數(shù)的參數(shù)是一定要寫的——有幾個就得寫幾個——因為你不寫的話實例就無法構(gòu)造出來。
5. 2.         構(gòu)造函數(shù)參數(shù)的順序不能錯，這個很容易理解——調(diào)用任何一個函數(shù)你都不能改變參數(shù)的順序——除非它有相應(yīng)的重載（Overload）。因為這個順序的固定的，所以有些書里管這些參數(shù)稱為“定位參數(shù)”，意即“個數(shù)和位置固定的參數(shù)”。
6. 3.         對Attribute實例的屬性的賦值可有可無——反正它會有一個默認(rèn)值。而且，先對哪個屬性賦值、后對哪個屬性賦值不受限制。有些書管這些為屬性賦值的參數(shù)叫“具名參數(shù)”——令人匪夷所思。

自己動手寫Attribute

這回我們拋棄.NET Framework給我們準(zhǔn)備好的各種Attribute，從頭寫一個全新的Attribute——Oyster。

下面我給出一個完整的小例子：

//======水之真諦=======//
//    上善若水,潤物無聲 //
/*  http://blog.csdn.net/FantasiaX  */

using System;
namespace OysterAttributeSample
{
         class Oyster: System.Attribute                         // 必需以System.Attribute類為基類
         {
                   // Kind屬性，默認(rèn)值為null
                   private string kind;
                   public string Kind
                   {
                            get { return kind; }
                            set { kind = value; }
                   }

// Age屬性，默認(rèn)值為
                   private uint age;
                   public uint Age
                   {
                            get { return age; }
                            set { age = value; }
                   }

// 值為null的string是危險的，所以必需在構(gòu)造函數(shù)中賦值
                   public Oyster(string arg)                                     // 定位參數(shù)
                   {
                            this.Kind = arg;
                   }
         }

[Oyster("Thorny ", Age=3)]    // 3年的多刺牡蠣附著在輪船（這是一個類）上。注意：對屬性的賦值是在圓括號里完成的！
         class Ship
         {
                   [Oyster("Saddle")]          // 0年的鞍形牡蠣附著在船舵（這是一個數(shù)據(jù)成員）上，Age使用的是默認(rèn)值，構(gòu)造函數(shù)的參數(shù)必需完整
                   public string Rudder;
         }

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

為了不把代碼拖的太長，上面這個例子中Oyster類的構(gòu)造函數(shù)只有一個參數(shù)，所以對“定位參數(shù)”體現(xiàn)的還不夠淋漓盡致。大家可以再為Oyster類添加幾個屬性，并在構(gòu)造函數(shù)里多設(shè)置幾個參數(shù)，體驗一下Attribute實例化時對參數(shù)個數(shù)及參數(shù)位置的敏感性。

能被Attribute所附著的目標(biāo)

讓我們思考這樣一個問題：牡蠣可以附著在船底、礁石上、橋墩上……甚至是別的牡蠣身上，那么Attribute呢？都可以將自己的實例附著在什么目標(biāo)上呢？

這個問題的答案隱藏在AttributeTargets這個枚舉類型里——這個類型的可取值集合為

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

All                                                  Assembly                                    Class                                             Constructor

Delegate                                     Enum                                             Event                                             Field

GenericParameter                   Interface                                       Method                                         Module

Parameter                                   Property                                       ReturnValue                               Struct

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

一共是16個可取值。

不過，上面這張表是按字母順序排列的，并不代表它們真實值的排列順序。使用下面這個小程序可以查看每個枚舉值對應(yīng)的整數(shù)值。

// =<水之真諦>=
// http://blog.csdn.net/FantasiaX
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");
                   }
         }
}

程序的運行結(jié)果是：

可能出乎你的預(yù)料——它們的值并不是步長值為1的線性遞增。你觀察出什么規(guī)律來了嗎？提醒你一下：從二進制的角度來考慮喔！！

我想你一定發(fā)現(xiàn)了規(guī)律——除了All的值之外，每個值的二進制形式中只有一位是“1”，其余位全是“0”。這就是枚舉值的另一種用法——標(biāo)識位。那么，標(biāo)識位有什么好處呢？

考慮這樣一種情況：我們的Attribute要求既能附著在類上，又能附著在類的方法上，應(yīng)該怎么做呢？

我們知道，C#中有一個操作符“|”（也就是按位求“或”）。有了它，我們只需要書寫

AttributeTargets.Class | AttributeTargets.Method

就可以了。因為這兩個枚舉值的標(biāo)識位（也就是那個唯一的“1”）是錯開的，所以只需要按位求或就解決問題了。我想，聰明的你一定立刻就能解釋為什么AttributeTargets.All的值是32767了吧:p

OK，了解了這些之后，我們應(yīng)該怎樣控制一個Attribute的附著目標(biāo)呢？

默認(rèn)情況下，當(dāng)我們聲明并定義一個新Attribute類時，它的可附著目標(biāo)是AttributeTargets.All。大多數(shù)情況下AttributeTargets.All就已經(jīng)滿足需求了，不過，如果你非要對它有所限制，那就要費點兒周折了。

還拿我們上面創(chuàng)建的OysterAttribute舉例——如果你想把它的附著目標(biāo)限制為只有“類”和“值域”，你就應(yīng)該這樣書寫：

[AttributeUsage(AttributeTargets.Class|AttributeTargets.Field)]
         class Oyster : System.Attribute     
         {
                   // OysterAttribute類的具體實現(xiàn)
         }

沒想到吧！原來是用Attribute（的實例）附著在Attribute（類）上！本來嗎，Attribute的本質(zhì)就是類，而AttributeTargets.Class 又說明Attribute可以附著在類上，所以，使用Attribute來“修飾”Attribute也就順理成章了J

最后，細(xì)心的讀者可能會問這樣兩個問題：

1. 1.         如果一個Attribute附著在了某個類上，那么這個Attribute會為會隨著繼承關(guān)系也附著在派生類上呢？
2. 2.         可不可以像多個牡蠣附著在同一艘船上那樣，讓一個Attribute的多個實例附著在同一個目標(biāo)上呢？

Very good! 這真是兩個好問題！請看下面的代碼：

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Field, Inherited = false, AllowMultiple = true)]
         class Oyster : System.Attribute     
         {
                   // OysterAttribute類的具體實現(xiàn)
         }

原來，AttributeUsage這個用來專門修飾Attribute的Attribute除了可以控制修飾目標(biāo)外，還能決定被它修飾的Attribute是否能夠隨宿主“遺傳”以及是否可以使用多個實例來修飾同一個目標(biāo)！

OK，大家猜一猜，修飾ConditionalAttribute的AttributeUsage會是什么樣子呢？（提示：答案在MSDN里。）

總結(jié)

以上是生活随笔為你收集整理的深入浅出Attribute（二）的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。