----------
this:
1 類別 (Class) 的目前執行個體 (Instance)
2 擴充方法之第一個參數的修飾詞 (Modifier)。 

靜態成員函式存在於類別層級，且非物件的一部分，所以不具有 this 指標。 在靜態方法中參考 this 是錯誤的.

----------
索引子
public int this[int param]
  {
      get { return array[param]; }
      set { array[param] = value; }
  }
----------
class Employee
          {
              private string name;
              private string alias;
              private decimal salary = 3000.00m;
  
              // Constructor:
  
              public Employee(string name, string alias)
              {
                  // Use this to qualify the fields, name and alias:
  
                  this.name = name;
                  this.alias = alias;
              }
              // Printing method:
  
              public void printEmployee()
              {
                  Console.WriteLine("Name: {0}\nAlias: {1}", name, alias);
                  // Passing the object to the CalcTax method by using this:
  
                  Console.WriteLine("Taxes: {0:C}", Tax.CalcTax(this));
              }
  
              public decimal Salary
              {
                  get { return salary; }
              }
          }
  
          class Tax
          {
              public static decimal CalcTax(Employee E)
              {
                  return 0.08m * E.Salary;
              }
          }
  
          class MainClass
          {
              static void Main()
              {
                  // Create objects:
  
                  Employee E1 = new Employee("Mingda Pan", "mpan");
  
                  // Display results:
  
                  E1.printEmployee();
              }
          }
          /*
        Output:
            Name: Mingda Pan
            Alias: mpan
            Taxes: $240.00
         */

----------
擴充方法1

擴充方法讓您能將方法「加入」至現有型別，而不需要建立新的衍生型別 (Derived Type)、重新編譯，或是修改原始型別。擴充方法是一種特殊的靜態方法，但是需將它們當成擴充型別上的執行個體方法 (Instance Method) 來呼叫。

擴充方法是定義為靜態方法，但使用執行個體方法語法進行呼叫。擴充方法的第一個參數指定方法進行作業的型別，而這個參數的前面需加上 this 修飾詞 (Modifier)。 使用 using 指示詞，將命名空間 (Namespace) 明確匯入至原始程式碼時，擴充方法才會進入範圍中。 

下列範例顯示針對 System.String 類別 (Class) 定義的擴充方法。 請注意，擴充方法是定義在非巢狀且非泛型靜態類別內：
namespace ExtensionMethods
  {
      public static class MyExtensions
      {
          public static int WordCount(this String str)
          {
              return str.Split(new char[] { ' ', '.', '?' }, StringSplitOptions.RemoveEmptyEntries).Length;
          }
      }   
  }

使用這個 using 指示詞即可將 WordCount 擴充方法帶入範圍中： 
using ExtensionMethods;

而使用下列語法，則可以從應用程式中呼叫它：
string s = "Hello Extension Methods";
  int i = s.WordCount();

在您的程式碼中，可以利用執行個體方法語法來叫用 (Invoke) 擴充方法。不過，編譯器 (Compiler) 產生的中繼語言 (Intermediate Language，IL) 會將您的程式碼轉譯為對靜態方法的呼叫。因此，實際上並未違反封裝 (Encapsulation) 的準則。事實上，擴充方法無法存取它們所擴充之型別中的私用變數。


namespace Extensions
{
  using System;
  using ExtensionMethodsDemo1;

     // Define extension methods for any type that implements IMyInterface.
     public static class Extension
     {
        public static void MethodA(this IMyInterface myInterface, int i)
        {
            Console.WriteLine("Extension.MethodA(this IMyInterface myInterface, int i)");
        }

        public static void MethodA(this IMyInterface myInterface, string s) 
        {
            Console.WriteLine("Extension.MethodA(this IMyInterface myInterface, string s)");
        }

        // This method is never called, because the three classes implement MethodB.
        public static void MethodB(this IMyInterface myInterface) 
        {
            Console.WriteLine("Extension.MethodB(this IMyInterface myInterface)");
        }
    }
}
namespace ExtensionMethodsDemo1
{
    using System;
    using Extensions;

    public interface IMyInterface
    {
        void MethodB();
    }

    class A : IMyInterface 
    {
        public void MethodB(){Console.WriteLine("A.MethodB()");}
    } 

    class B : IMyInterface
    {
        public void MethodB() { Console.WriteLine("B.MethodB()"); }
        public void MethodA(int i) { Console.WriteLine("B.MethodA(int i)"); }
    }

    class C : IMyInterface
    {
        public void MethodB() { Console.WriteLine("C.MethodB()"); }
        public void MethodA(object obj) { Console.WriteLine("C.MethodA(object obj)"); }
    }

    class ExtMethodDemo
    {
        static void Main(string[] args)
        {
            A a = new A();
            B b = new B();
            C c = new C();
            TestMethodBinding(a,b,c);
        }

        static void TestMethodBinding(A a, B b, C c)
        {
            // A has no methods, so each call resolves to 
            // the extension methods whose signatures match.
            a.MethodA(1);           // Extension.MethodA(object, int)
            a.MethodA("hello");     // Extension.MethodA(object, string)
            a.MethodB();            // A.MethodB()

            // B itself has a method with this signature.
            b.MethodA(1);           // B.MethodA(int)
            b.MethodB();            // B.MethodB()

            // B has no matching method, but Extension does.
            b.MethodA("hello");     // Extension.MethodA(object, string)

            // In each case C has a matching instance method.
            c.MethodA(1);           // C.MethodA(object)
            c.MethodA("hello");     // C.MethodA(object)
            c.MethodB();            // C.MethodB()
        }
    }
}
/* Output:
    Extension.MethodA(this IMyInterface myInterface, int i)
    Extension.MethodA(this IMyInterface myInterface, string s)
    A.MethodB()
    B.MethodA(int i)
    B.MethodB()
    Extension.MethodA(this IMyInterface myInterface, string s)
    C.MethodA(object obj)
    C.MethodA(object obj)
    C.MethodB()
 */



----------
擴充方法2

最常見的擴充方法為 LINQ 標準查詢運算子，這些運算子會將查詢功能加入現有的 System.Collections.IEnumerable 與 System.Collections.Generic.IEnumerable<T>型別。 若要使用標準查詢運算子，請先利用 using System.Linq 指示詞將運算子加入目前的範圍。 接著，任何實作 IEnumerable<T>的型別都會具有執行個體方法，如 GroupBy、 OrderBy、 Average 等。 如果在 IEnumerable<T>型別 (如 List<T>或 Array) 的執行個體後面輸入「點」，則可以在 IntelliSense 陳述式完成功能中看到這些額外方法。 

下列範例顯示如何在整數陣列上呼叫標準查詢運算子 OrderBy 方法。 用括號括住的運算式就是 Lambda 運算式。許多標準查詢運算子會將 Lambda 運算式當成參數，但這不是擴充方法的需求。如需詳細資訊，請參閱 Lambda 運算式 (C# 程式設計手冊)。 

class ExtensionMethods2    
  {
  
      static void Main()
      {            
          int[] ints = { 10, 45, 15, 39, 21, 26 };
          var result = ints.OrderBy(g => g);
          foreach (var i in result)
          {
              System.Console.Write(i + " ");
          }           
      }        
  }
  //Output: 10 15 21 26 39 45


----------