C#3.0擴展方法學習篇

時間 2019-11-08

標籤 c#3.0 擴展方法學習欄目 C# 简体版

原文原文鏈接

什麼是類的擴展方法

擴展方法使您可以向現有類型「添加」方法，而無需建立新的派生類型、從新編譯或以其餘方式修改原始類型。c#

MSDNide

Extension methods enable you to "add" methods to existing types without creating a new derived type, recompiling, or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called as if they were instance methods on the extended type.this

傳統的模式下若是想爲一個類型（class）添加一個額外的自定義的特殊的邏輯上，或者業務上的新方法時，你必須從新定義的一個類型來繼承原有的的方法，用繼承類或者接口，可是有些用sealed修飾的，這時候就沒法被繼承，例如String,值類型，sealed修飾的類。spa

擴展方法是C#3.0這個版本提出來的。解決了必須由繼承才能擴展的某個類的弊端，最重要的一點就是很好用。code

平時在咱們使用的過程當中也常常的見到，如

這其中的OrderBy方法就是擴展方法。

MSDN

注意：blog

擴展方法必須在非嵌套、非泛型的靜態類中定義。繼承

Note that it is defined inside a non-nested<非嵌套>, non-generic<非泛型的> static<靜態> class:接口

擴展方法的規則有如下幾點：three

擴展方法必須是擴展方法必須是非嵌套、非泛型的靜態類中定義的;
擴展方法的第一個參數要用this關鍵字修飾;
第一個方法參數不能有ref 或則out關鍵字修飾的參數;

擴展方法的調用有兩個步驟

引用項目的命名空間；
參數調用兩種；

和傳統的調用方法同樣使用<ExtendClass>.<ExtendClassMethod>（參數,參數+?）
<參數類型>.<ExtendClassMethod>(參數+?)

高級點的應用

在編譯時綁定擴展方法<MSDN>

你可使用擴展方法來擴展一個類和接口，而不須要去重寫他們

  1 // Define an interface named IMyInterface.
  2 namespace DefineIMyInterface
  3 {
  4     using System;
  5 
  6     publicinterface IMyInterface
  7     {
  8         // Any class that implements IMyInterface must define a method
  9         // that matches the following signature.
 10         void MethodB();
 11     }
 12 }
 13 
 14 
 15 // Define extension methods for IMyInterface.
 16 namespace Extensions
 17 {
 18     using System;
 19     using DefineIMyInterface;
 20 
 21     // The following extension methods can be accessed by instances of any 
 22     // class that implements IMyInterface.
 23     publicstaticclass Extension
 24     {
 25         publicstaticvoid MethodA(this IMyInterface myInterface, int i)
 26         {
 27             Console.WriteLine
 28                 ("Extension.MethodA(this IMyInterface myInterface, int i)");
 29         }
 30 
 31         publicstaticvoid MethodA(this IMyInterface myInterface, string s)
 32         {
 33             Console.WriteLine
 34                 ("Extension.MethodA(this IMyInterface myInterface, string s)");
 35         }
 36 
 37         // This method is never called in ExtensionMethodsDemo1, because each 
 38         // of the three classes A, B, and C implements a method named MethodB
 39         // that has a matching signature.
 40         publicstaticvoid MethodB(this IMyInterface myInterface)
 41         {
 42             Console.WriteLine
 43                 ("Extension.MethodB(this IMyInterface myInterface)");
 44         }
 45     }
 46 }
 47 
 48 
 49 // Define three classes that implement IMyInterface, and then use them to test
 50 // the extension methods.
 51 namespace ExtensionMethodsDemo1
 52 {
 53     using System;
 54     using Extensions;
 55     using DefineIMyInterface;
 56 
 57     class A : IMyInterface
 58     {
 59         publicvoid MethodB() { Console.WriteLine("A.MethodB()"); }
 60     }
 61 
 62     class B : IMyInterface
 63     {
 64         publicvoid MethodB() { Console.WriteLine("B.MethodB()"); }
 65         publicvoid MethodA(int i) { Console.WriteLine("B.MethodA(int i)"); }
 66     }
 67 
 68     class C : IMyInterface
 69     {
 70         publicvoid MethodB() { Console.WriteLine("C.MethodB()"); }
 71         publicvoid MethodA(object obj)
 72         {
 73             Console.WriteLine("C.MethodA(object obj)");
 74         }
 75     }
 76 
 77     class ExtMethodDemo
 78     {
 79         staticvoid Main(string[] args)
 80         {
 81             // Declare an instance of class A, class B, and class C.
 82             A a = new A();
 83             B b = new B();
 84             C c = new C();
 85 
 86             // For a, b, and c, call the following methods://      -- MethodA with an int argument//      -- MethodA with a string argument//      -- MethodB with no argument.// A contains no MethodA, so each call to MethodA resolves to // the extension method that has a matching signature.
 87             a.MethodA(1);           // Extension.MethodA(object, int)
 88             a.MethodA("hello");     // Extension.MethodA(object, string)// A has a method that matches the signature of the following call// to MethodB.
 89             a.MethodB();            // A.MethodB()// B has methods that match the signatures of the following// method calls.
 90             b.MethodA(1);           // B.MethodA(int)
 91             b.MethodB();            // B.MethodB()// B has no matching method for the following call, but // class Extension does.
 92             b.MethodA("hello");     // Extension.MethodA(object, string)// C contains an instance method that matches each of the following// method calls.
 93             c.MethodA(1);           // C.MethodA(object)
 94             c.MethodA("hello");     // C.MethodA(object)
 95             c.MethodB();            // C.MethodB()
 96         }
 97     }
 98 }
 99 /* Output:
100     Extension.MethodA(this IMyInterface myInterface, int i)
101     Extension.MethodA(this IMyInterface myInterface, string s)
102     A.MethodB()
103     B.MethodA(int i)
104     B.MethodB()
105     Extension.MethodA(this IMyInterface myInterface, string s)
106     C.MethodA(object obj)
107     C.MethodA(object obj)
108     C.MethodB()
109  */