6、tribute>(member).Length > 0;
}
///
/// Gets the attributes.
///
/// The type of the attribute.
/// The member.
///
public static TAttribute[] GetAttributes(
this
7、MemberInfo member)
where TAttribute : Attribute
{
var attributes =
member.GetCustomAttributes(typeof(TAttribute), true);
return (TAttribute[])attributes;
}
如何使用，請看下面的代碼，我們使用lambda表達式獲取某個方法，然后獲取其上面的Attribute:
[Fact]
public void GetHttpPostAttributeFromCreateAction()
8、
{
// Arrange
var controller = GetEmployeeController(new MemeoryEmployeeBoService());
//Act
bool hasPostAttribute =controller.GetMethod(e => e.Create(new Employee()))
.HasAttribute();
// Assert
Assert.True(hasPostAttribute);
}
擴展
9、方法的實現(xiàn)
1.首先，我們需要在項目中添加自己的一個類型，此處為ProjectExt,其中的方法與之前定義的方法大致上無區(qū)別，只是在方法中第一個參數(shù)前面添加了this關(guān)鍵字，this關(guān)鍵字必須是在方法參數(shù)中第一個參數(shù)的前面，不可以移位。
view source
print?
01.public static ?class ProjectExt
02. {
03. ///
04. /// 向字符串追加字符
05. ///
06. /// 字符串
07. ///
10、me="AppendStr">需要追加的字符串
08. /// 追加完成的字符對象
09. public static ?string AppendToLeft(this ?string obj,string AppendStr)
10. {
11. return AppendStr + obj;
12. }
13. }
2.像在調(diào)用FCL本身類庫的方法一樣調(diào)用AppendToLeft，我們的代碼看起來更美麗整潔！
view source
print?
1.static void Main(string[] ar
11、gs)
2.{
3. string Tel = "87763445";
4. Console.WriteLine("Tel:"+ Tel.AppendToLeft("020-"));
5.}
輸出：020-87763445
我們可以淺而易懂的看到兩者之間的區(qū)別，這就是擴展方法帶來的便捷之處，讓我們的代碼更加的整潔，在使用擴展方法的時候必須注意一下幾點：
1.第一個參數(shù)之前必須有this關(guān)鍵字，不可變動
2.在添加擴展方法的類型中，類型本身和類型所包含的方法必須是靜態(tài)的。
3.由于這里是按類型識別，所以不應該將擴展方法的第一個參數(shù)類型設(shè)為object，這樣會造成無論使用
12、什么類型，都會擴展該方法。
4.必須考慮將來FCL可能會添加相同的方法，如果FCL在以后的版本中添加了該方法，那么C#會優(yōu)先選擇FCL所定義的方法。
最后的補充：
擴展方法為什么要添加一個this在前面呢？這引用類型的特性有關(guān)，this指向調(diào)用者本身，所以改變的也是調(diào)用者本身的實例，至于為什么在Visual Studio中能找到該方法，這是C#編輯器的功能，其中有一個搜索的過程，如果要使用不同命名空間下的擴展方法，請在代碼頂端using該命名空間。另外，由于結(jié)構(gòu)(struct)不能聲明為靜態(tài)，但是擴展方法必須聲明在靜態(tài)類型之中，所以不能在結(jié)構(gòu)(struct)中聲明擴展方法，這點必須要
13、注意！
我們在開發(fā)經(jīng)常要使用Enum類型，今天我們用擴展方法來為Enum類型加入業(yè)務邏輯. 有以下的代碼：
1: ///
2: /// StorageProviders
3: ///
4: [Serializable]
5: public enum StorageProviders
6: {
7: ///
8: /// LuceneIo
9:
14、 ///
10: LuceneIo = 0,
11: ///
12: /// LuceneVirtual
13: ///
14: LuceneVirtual = 1
15: }
然后寫一個擴展方法：
1: ///
2: /// StorageProvidersExtensions
3: ///
15、4: public static class StorageProvidersExtensions
5: {
6: ///
7: /// Determines whether the specified provider is virtual.
8: ///
9: /// The provider.
10: ///
16、 11: /// true if the specified provider is virtual; otherwise, false.
12: ///
13: public static bool IsVirtual(this StorageProviders provider)
14: {
15: return provider == StorageProviders.LuceneVirtual;
16
17、: }
17: }
好了，讓我們來看如何使用：
1: [Test]
2: public void TestEnumExtesnsionMethod()
3: {
4: StorageProviders storageProviders = StorageProviders.LuceneVirtual;
5: Assert.IsTrue(storageProviders.IsVirtual());
6:
18、 }
為對象添加擴展屬性動態(tài)獲取數(shù)據(jù)
由于項目需要常常會遇到為某一個對象動態(tài)添加屬性的情況，而以前我的實現(xiàn)方式是創(chuàng)建一個字典用于存放對象實例和它的值，但是往往光這么做是不夠的，例如想在對象的某個屬性值改變的時候做點什么都要寫很多的代碼，所以想是不是能夠?qū)⑦@一類功能進行一下封裝。后來因為學習WPF的緣故，想到依賴屬性的思想和我需要的功能相近，但是又不能叫我把每一個想要添加擴展的對象類都去繼承DependencyObject吧，而且有些類是封閉的不能夠繼承，所以依賴屬性不能滿足我的需求。不過說到底依賴屬性還是個不錯的東西，接下來我們將實現(xiàn)一個類似的東西 - 擴展屬性。
19、
在實現(xiàn)擴展屬性時我也參考了依賴屬性的源碼，它的設(shè)計思想的確很“先進”。
1.先來看看擴展屬性的使用方式：
1: private static ExtendProperty InfoProperty = 2: ExtendProperty.RegisterProperty("Info", typeof(string), typeof(UserInfo),"you win"); 3: var user = new UserInfo() { Age=21, Name="maxzhang" }; 4: 5: user.SetValue(InfoProperty, "hello"); 6
20、: string rrr = (string)user.GetValue(InfoProperty);
是不是看著特別像依賴屬性呢，往下面看：
1: dynamic userDynamic = user.AsDynamic(); 2: rrr= userDynamic.Info; 3: userDynamic.Info = "1"; 4: userDynamic.Age = 50; 5: rrr = userDynamic.Info;
我為擴展屬性添加了動態(tài)性使對象屬性的創(chuàng)建和訪問更加方便，這里如果Info屬性在前面沒有用RegisterProperty方法定義過它會自動生成一個擴展
21、屬性且添加屬性值.如果訪問了它的普通屬性屬性也是正常使用的。以上兩個例子中
UserInfo類的定義是 public class UserInfo : ExtendObject { public string Name { set; get; } public int Age { set; get; }},你可能會問這不是和依賴屬性一樣嗎？只是把繼承DependencyObject換成了繼承你自己寫的ExtendObject 了。是的這樣看是差不多的，不過以上的情況還是有一個好處的就是我可以在任何項目里引用它。
如果遇到了不能繼承的情況呢，其實這種情況有很多。接…
publ
22、ic class UserInfo1 { public string Name{set;get;} } 這個類不繼承任何類。
解決它這里引入了新的擴展類型AttachObject ：
1: AttachObject user1Aobj = new AttachObject(user1); 2: var dyuser = user1Aobj.ToDynamicAttachObject(); 3: //var dyuser = user1.ToDynamicAttachObject(); 4: dyuser.Memo = "haha my name i's maxzhang......
23、"; 5: rrr = dyuser.Memo;
其實AttachObject 類型也是一個ExtendObject 可以把它看成是一個ExtendObject 的裝飾。
2.下面我們來看看這些都是怎么實現(xiàn)的
(1).ExtendProperty
與依賴屬性類似，在ExtendProperty類中用了一個Dictionary來存儲系統(tǒng)中要用到的擴展屬性，這樣實現(xiàn)也達到了節(jié)省內(nèi)存資源的目地。且這個類的構(gòu)造器是一個private的，這樣也就實現(xiàn)了一個單例模式，只有在RegisterProperty方法才能創(chuàng)造出一個ExtendProper
24、ty來.
RegisterPropertypublic static ExtendProperty RegisterProperty(string propertyName, Type propertyType, Type ownerType,object defaultValue)
{
var property = new ExtendProperty(propertyName, propertyType,ownerType);
property.OverrideDefaultValue(ownerType, defaultValue);
ExtendPropertysProv
25、ider.Set(property.GetHashCode(), property);
return property;
}
用GetHashCode來標示我們這個屬性的唯一性，這里我重寫了這個函數(shù)它的值是this.ownerType.GetHashCode()^this.propertyName.GetHashCode(),也就是說用注冊這個屬性的類型和屬性的名稱確定了這個擴展屬性。我們看到OverrideDefaultValue這個方法它是用來重寫屬性的默認值的，在這個系統(tǒng)中如果某個對象的擴展屬性沒有賦過值或說沒有改變過，那么它應該在訪問這個屬性的時候取得一個默認值而且這個默認值
26、應該是所有相同注冊類型的對象共有的，而在用普通屬性存儲的對象中我們實例化對象后會在每一個對象中保存相應的默認值，這樣無疑是浪費了內(nèi)存。而且OverrideDefaultValue與AddOwner方法一起使用可以達到屬性繼承的目的。我們來看看AddOwner方法的實現(xiàn)：AddOwnerpublic ExtendProperty AddOwner(Type ownerType,object defaultValue)
{
int newOwnerHash = ownerType.GetHashCode() ^ this.PropertyName.GetHashCode();
if(defa
27、ultValue!=null)
this.OverrideDefaultValue(ownerType, defaultValue);
ExtendPropertysProvider.Set(newOwnerHash, this);
return this;
}
使用AddOwner方法我們就在原有的擴展屬性上添加了一個指向它的引用從而達到繼承的目地，怎么重寫屬性默認值呢？其實很簡單默認值在擴展屬性中保存在一個的字典中通過不同的類型我們就可以訪問不同類型的相同屬性的默認值了。 (2).ExtendObject
這里ExtendObject就沒什么好說
28、的了，原理就是其內(nèi)部有一個Dictionary propertyValues 存儲著不同對象的值，用自身的GetHashCode ^ 擴展屬性的HashCode 確定值的唯一性。
ExtendObject的源碼，呵呵 public class ExtendObject
{
protected Dictionary propertyValues = new Dictionary();
private Type OwnerType = null;
public ExtendObject()
{
Ow
29、nerType = this.GetType();
}
public override int GetHashCode()
{
return base.GetHashCode();
}
public virtual object GetOwner()
{
return this;
}
protected void AttachOwner(Type ownerType)
{
this.OwnerType = ownerType;
}
public bool IsExtendProperty(string propertyName)
{
return
30、 !OwnerType.GetProperties().Any(p => p.Name == propertyName); ;
}
protected ExtendProperty GetProperty(string name)
{
int propertyKey = OwnerType.GetHashCode() ^ name.GetHashCode();
var property = ExtendPropertysProvider.Get(propertyKey);
return property;
}
public object GetValue(ExtendP
31、roperty property)
{
int propertyHash = property.GetHashCode();
int key = this.GetHashCode() ^ propertyHash;
object result = null;
if (!propertyValues.TryGetValue(key, out result))
{
result = property.GetDefaultValue(this.OwnerType);
}
return result;
}
public bool ClearValue(ExtendPr
32、operty property)
{
bool result = false;
int propertyHash = property.GetHashCode();
int key = this.GetHashCode() ^ propertyHash;
if (propertyValues.Keys.Any(k => k == key))
{
propertyValues.Remove(key);
result = true;
}
return result;
}
public void SetValue(ExtendProperty property, ob
33、ject value)
{
var changedItemArgs = new ExtendPropertyValueChangedArgs();
int propertyHash = property.GetHashCode();
int key = this.GetHashCode() ^ propertyHash;
if (propertyValues.Keys.Any(k => k == key))
{
changedItemArgs.OldValue = propertyValues[key];
propertyValues[key] = value;
}
e
34、lse
{
changedItemArgs.OldValue = null;
propertyValues.Add(key, value);
}
changedItemArgs.Item = GetOwner();
changedItemArgs.PropertyType = property.PropertyType;
changedItemArgs.PropertyName = property.PropertyName;
changedItemArgs.NewValue = value;
property.OnValueChanged(changedItemAr
35、gs);
}
public bool ClearValue(string propertyName)
{
var property = this.GetProperty(propertyName);
if (property != null)
return this.ClearValue(property);
return false;
}
public object GetValue(string propertyName)
{
var property = this.GetProperty(propertyName);
if (property != n
36、ull)
return this.GetValue(property);
return null;
}
public void SetValue(string propertyName, object value)
{
var property = this.GetProperty(propertyName);
if (property != null)
{
this.SetValue(property, value);
}
else
{
var newProperty = ExtendProperty.RegisterProperty(propertyN
37、ame, typeof(object), OwnerType);
this.SetValue(newProperty, value);
}
}
public ExtendDynamicObject AsDynamic()
{
return new ExtendDynamicObject(this);
}
}
不過這里還是有一個小小的技巧的就是OwnerType這個屬性和AttachOwner方法，默認的OwnerType屬性的值是擴展對象本身的Type，但是通過 AttachOwner方法我們可以改變這個屬性從而達到將不繼承自ExtendObject類型的對象裝飾成E
38、xtendObject
對象的目地。
(3).也就是AttachObject
AttachObject類通過調(diào)用AttachOwner方法使用了這個技巧，同時把同樣為ExtendObject的對象的屬性統(tǒng)統(tǒng)都Copy過來.
AttachObjectpublic class AttachObject : ExtendObject
{
private object owner;
public AttachObject(object obj)
: base()
{
owner = obj;
if (owner is ExtendObject)
{
Typ
39、e ownerType = typeof(ExtendObject);
FieldInfo fInfo = ownerType.GetField("propertyValues", BindingFlags.Default | BindingFlags.NonPublic | BindingFlags.Instance);
var ownerValues = fInfo.GetValue(owner) as Dictionary;
foreach (var v in ownerValues)
this.propertyValues.Add(v.Key, v.Value);
}
this.AttachOwner(owner.GetType());
}
public override object GetOwner()
{
return owner;
}
public override int GetHashCode()
{
return owner.GetHashCode();
}
}
CSharp擴展方法和擴展屬性
