委託是一種引用方法的類型。一旦爲委託分配了方法，委託將與該方法具備徹底相同的行爲。委託方法的使用能夠像其餘任何方法同樣，具備參數和返回值，以下面的示例所示：算法
public delegate int PerformCalculation(int x, int y);
與委託的簽名（由返回類型和參數組成）匹配的任何方法均可以分配給該委託。這樣就能夠經過編程方式來更改方法調用，還能夠向現有類中插入新代碼。只要知道委託的簽名，即可以分配本身的委託方法。數據庫
將方法做爲參數進行引用的能力使委託成爲定義回調方法的理想選擇。例如，能夠向排序算法傳遞對比較兩個對象的方法的引用。分離比較代碼使得能夠採用更通用的方式編寫算法。編程
委託是一種安全地封裝方法的類型，它與 C 和 C++ 中的函數指針相似。與 C 中的函數指針不一樣，委託是面向對象的、類型安全的和保險的。委託的類型由委託的名稱定義。下面的示例聲明瞭一個名爲 Del 的委託，該委託能夠封裝一個採用字符串做爲參數並返回 void 的方法。this
public delegate void Del(string message);
構造委託對象時，一般提供委託將包裝的方法的名稱或使用匿名方法。實例化委託後，委託將把對它進行的方法調用傳遞給方法。調用方傳遞給委託的參數被傳遞給方法，來自方法的返回值（若是有）由委託返回給調用方。這被稱爲調用委託。能夠將一個實例化的委託視爲被包裝的方法自己來調用該委託。例如：
// Create a method for a delegate. public static void DelegateMethod(string message) { System.Console.WriteLine(message); }
// Instantiate the delegate. Del handler = DelegateMethod; // Call the delegate. handler("Hello World");
委託類型派生自 .NET Framework 中的 Delegate 類。委託類型是密封的，不能從 Delegate 中派生委託類型，也不可能從中派生自定義類。因爲實例化委託是一個對象，因此能夠將其做爲參數進行傳遞，也能夠將其賦值給屬性。這樣，方法即可以將一個委託做爲參數來接受，而且之後能夠調用該委託。這稱爲異步回調，是在較長的進程完成後用來通知調用方的經常使用方法。以這種方式使用委託時，使用委託的代碼無需瞭解有關所用方法的實現方面的任何信息。此功能相似於接口所提供的封裝。有關更多信息，請參見什麼時候使用委託而不使用接口。
回調的另外一個常見用法是定義自定義的比較方法並將該委託傳遞給排序方法。它容許調用方的代碼成爲排序算法的一部分。下面的示例方法使用 Del 類型做爲參數：
public void MethodWithCallback(int param1, int param2, Del callback) { callback("The number is: " + (param1 + param2).ToString()); }
而後能夠將上面建立的委託傳遞給該方法：
MethodWithCallback(1, 2, handler);
在控制檯中將收到下面的輸出：
The number is: 3
在將委託用做抽象概念時，MethodWithCallback 不須要直接調用控制檯 -- 設計它時無需考慮控制檯。MethodWithCallback 的做用只是準備字符串並將該字符串傳遞給其餘方法。此功能特別強大，由於委託的方法可使用任意數量的參數。
將委託構造爲包裝實例方法時，該委託將同時引用實例和方法。除了它所包裝的方法外，委託不瞭解實例類型，因此只要任意類型的對象中具備與委託簽名相匹配的方法，委託就能夠引用該對象。將委託構造爲包裝靜態方法時，它只引用方法。考慮下列聲明：
public class MethodClass { public void Method1(string message) { } public void Method2(string message) { } }
加上前面顯示的靜態 DelegateMethod，如今咱們有三個方法可由 Del 實例進行包裝。
調用委託時，它能夠調用多個方法。這稱爲多路廣播。若要向委託的方法列表（調用列表）中添加額外的方法，只需使用加法運算符或加法賦值運算符（「+」或「+=」）添加兩個委託。例如：
MethodClass obj = new MethodClass(); Del d1 = obj.Method1; Del d2 = obj.Method2; Del d3 = DelegateMethod; //Both types of assignment are valid. Del allMethodsDelegate = d1 + d2; allMethodsDelegate += d3;
此時，allMethodsDelegate 在其調用列表中包含三個方法 -- Method1、Method2 和 DelegateMethod。原來的三個委託 d1、d2 和 d3 保持不變。調用 allMethodsDelegate 時，將按順序調用全部這三個方法。若是委託使用引用參數，則引用將依次傳遞給三個方法中的每一個方法，由一個方法引發的更改對下一個方法是可見的。若是任一方法引起了異常，而在該方法內未捕獲該異常，則該異常將傳遞給委託的調用方，而且再也不對調用列表中後面的方法進行調用。若是委託具備返回值和/或輸出參數，它將返回最後調用的方法的返回值和參數。若要從調用列表中移除方法，請使用減法運算符或減法賦值運算符（「-」或「-=」）。例如：
//remove Method1 allMethodsDelegate -= d1; // copy AllMethodsDelegate while removing d2 Del oneMethodDelegate = allMethodsDelegate - d2;
因爲委託類型派生自 System.Delegate，因此可在委託上調用該類定義的方法和屬性。例如，爲了找出委託的調用列表中的方法數，您能夠編寫下面的代碼：
int invocationCount = d1.GetInvocationList().GetLength(0);
在調用列表中具備多個方法的委託派生自 MulticastDelegate，這是 System.Delegate 的子類。因爲兩個類都支持 GetInvocationList，因此上面的代碼在兩種狀況下都適用。
多路廣播委託普遍用於事件處理中。事件源對象向已註冊接收該事件的接收方對象發送事件通知。爲了爲事件註冊，接收方建立了旨在處理事件的方法，而後爲該方法建立委託並將該委託傳遞給事件源。事件發生時，源將調用委託。而後，委託調用接收方的事件處理方法並傳送事件數據。給定事件的委託類型由事件源定義。有關更多信息，請參見事件（C# 編程指南）。
在編譯時，對分配了兩種不一樣類型的委託進行比較將產生編譯錯誤。若是委託實例靜態地屬於類型 System.Delegate，則容許進行比較，但在運行時將返回 false。例如：
delegate void Delegate1(); delegate void Delegate2(); static void method(Delegate1 d, Delegate2 e, System.Delegate f) { // Compile-time error. //Console.WriteLine(d == e); // OK at compile-time. False if the run-time type of f //is not the same as that of d. System.Console.WriteLine(d == f); }
委託能夠與命名方法關聯。使用命名的方法對委託進行實例化時，該方法將做爲參數傳遞，例如：
// Declare a delegate: delegate void Del(int x); // Define a named method: void DoWork(int k) { /* ... */ } // Instantiate the delegate using the method as a parameter: Del d = obj.DoWork;
這被稱爲使用命名的方法。使用命名方法構造的委託能夠封裝靜態方法或實例方法。在之前的 C# 版本中，使用命名的方法是對委託進行實例化的惟一方式。可是，在建立新方法的系統開銷沒必要要時，C# 2.0 容許您對委託進行實例化，並當即指定委託將在被調用時處理的代碼塊。這些被稱爲匿名方法（C# 編程指南）。
如下是聲明及使用委託的一個簡單示例。注意，委託 Del 和關聯的方法 MultiplyNumbers 具備相同的簽名
// Declare a delegate delegate void Del(int i, double j); class MathClass { static void Main() { MathClass m = new MathClass(); // Delegate instantiation using "MultiplyNumbers" Del d = m.MultiplyNumbers; // Invoke the delegate object. System.Console.WriteLine("Invoking the delegate using 'MultiplyNumbers':"); for (int i = 1; i <= 5; i++) { d(i, 2); } } // Declare the associated method. void MultiplyNumbers(int m, double n) { System.Console.Write(m * n + " "); } }
Invoking the delegate using 'MultiplyNumbers': 2 4 6 8 10
在下面的示例中，一個委託被同時映射到靜態方法和實例方法，並分別返回特定的信息。
// Declare a delegate delegate void Del(); class SampleClass { public void InstanceMethod() { System.Console.WriteLine("A message from the instance method."); } static public void StaticMethod() { System.Console.WriteLine("A message from the static method."); } } class TestSampleClass { static void Main() { SampleClass sc = new SampleClass(); // Map the delegate to the instance method: Del d = sc.InstanceMethod; d(); // Map to the static method: d = SampleClass.StaticMethod; d(); } }
A message from the instance method. A message from the static method.
在 2.0 以前的 C# 版本中，聲明委託的惟一方法是使用命名方法。C# 2.0 引入了匿名方法。
要將代碼塊傳遞爲委託參數，建立匿名方法則是惟一的方法。例如：
// Create a handler for a click event button1.Click += delegate(System.Object o, System.EventArgs e) { System.Windows.Forms.MessageBox.Show("Click!"); };
或
// Create a delegate instance delegate void Del(int x); // Instantiate the delegate using an anonymous method Del d = delegate(int k) { /* ... */ };
若是使用匿名方法，則沒必要建立單獨的方法，所以減小了實例化委託所需的編碼系統開銷。
例如，若是建立方法所需的系統開銷是沒必要要的，在委託的位置指定代碼塊就很是有用。啓動新線程便是一個很好的示例。無需爲委託建立更多方法，線程類便可建立一個線程而且包含該線程執行的代碼。
void StartThread() { System.Threading.Thread t1 = new System.Threading.Thread (delegate() { System.Console.Write("Hello, "); System.Console.WriteLine("World!"); }); t1.Start(); }
匿名方法的參數的範圍是 anonymous-method-block。
在目標在塊外部的匿名方法塊內使用跳轉語句（如 goto、break 或 continue）是錯誤的。在目標在塊內部的匿名方法塊外部使用跳轉語句（如 goto、break 或 continue）也是錯誤的。
若是局部變量和參數的範圍包含匿名方法聲明，則該局部變量和參數稱爲該匿名方法的外部變量或捕獲變量。例如，下面代碼段中的 n 便是一個外部變量：
int n = 0; Del d = delegate() { System.Console.WriteLine("Copy #:{0}", ++n); };
與局部變量不一樣，外部變量的生命週期一直持續到引用該匿名方法的委託符合垃圾回收的條件爲止。對 n 的引用是在建立該委託時捕獲的。
在 anonymous-method-block 中不能訪問任何不安全代碼。
下面的示例演示實例化委託的兩種方法：
使委託與匿名方法關聯。
使委託與命名方法 (DoWork) 關聯。
兩種方法都會在調用委託時顯示一條消息。
// Declare a delegate delegate void Printer(string s); class TestClass { static void Main() { // Instatiate the delegate type using an anonymous method: Printer p = delegate(string j) { System.Console.WriteLine(j); }; // Results from the anonymous delegate call: p("The delegate using the anonymous method is called."); // The delegate instantiation using a named method "DoWork": p = new Printer(TestClass.DoWork); // Results from the old style delegate call: p("The delegate using the named method is called."); } // The method associated with the named delegate: static void DoWork(string k) { System.Console.WriteLine(k); } }
The delegate using the anonymous method is called. The delegate using the named method is called.
委託和接口都容許類設計器分離類型聲明和實現。給定的接口可由任何類或結構繼承和實現；能夠爲任何類中的方法建立委託，前提是該方法符合委託的方法簽名。接口引用或委託可由不瞭解實現該接口或委託方法的類的對象使用。既然存在這些類似性，那麼類設計器什麼時候應使用委託，什麼時候又該使用接口呢？
在如下狀況中使用委託：
當使用事件設計模式時。
當封裝靜態方法可取時。
當調用方不須要訪問實現該方法的對象中的其餘屬性、方法或接口時。
須要方便的組合。
當類可能須要該方法的多個實現時。
在如下狀況中使用接口：
當存在一組可能被調用的相關方法時。
當類只須要方法的單個實現時。
當使用接口的類想要將該接口強制轉換爲其餘接口或類類型時。
當正在實現的方法連接到類的類型或標識時：例如比較方法。
使用單一方法接口而不使用委託的一個很好的示例是 IComparable 或 IComparable。IComparable 聲明 CompareTo 方法，該方法返回一個整數，以指定相同類型的兩個對象之間的小於、等於或大於關係。IComparable 可用做排序算法的基礎，雖然將委託比較方法用做排序算法的基礎是有效的，可是並不理想。由於進行比較的能力屬於類，而比較算法不會在運行時改變，因此單一方法接口是理想的。
將方法簽名與委託類型匹配時，協變和逆變爲您提供了必定程度的靈活性。協變容許方法具備的派生返回類型比委託中定義的更多。逆變容許方法具備的派生參數類型比委託類型中的更少。
class Mammals { } class Dogs : Mammals { } class Program { // Define the delegate. public delegate Mammals HandlerMethod(); public static Mammals FirstHandler() { return null; } public static Dogs SecondHandler() { return null; } static void Main() { HandlerMethod handler1 = FirstHandler; // Covariance allows this delegate. HandlerMethod handler2 = SecondHandler; } }
System.DateTime lastActivity; public Form1() { InitializeComponent(); lastActivity = new System.DateTime(); this.textBox1.KeyDown += this.MultiHandler; //works with KeyEventArgs this.button1.MouseClick += this.MultiHandler; //works with MouseEventArgs } // Event hander for any event with an EventArgs or // derived class in the second parameter private void MultiHandler(object sender, System.EventArgs e) { lastActivity = System.DateTime.Now; }
本示例演示如何組合多路廣播委託。委託對象的一個用途在於，可使用 + 運算符將它們分配給一個要成爲多路廣播委託的委託實例。組合的委託可調用組成它的那兩個委託。只有相同類型的委託才能夠組合。
- 運算符可用來從組合的委託移除組件委託。
delegate void Del(string s); class TestClass { static void Hello(string s) { System.Console.WriteLine(" Hello, {0}!", s); } static void Goodbye(string s) { System.Console.WriteLine(" Goodbye, {0}!", s); } static void Main() { Del a, b, c, d; // Create the delegate object a that references // the method Hello: a = Hello; // Create the delegate object b that references // the method Goodbye: b = Goodbye; // The two delegates, a and b, are composed to form c: c = a + b; // Remove a from the composed delegate, leaving d, // which calls only the method Goodbye: d = c - a; System.Console.WriteLine("Invoking delegate a:"); a("A"); System.Console.WriteLine("Invoking delegate b:"); b("B"); System.Console.WriteLine("Invoking delegate c:"); c("C"); System.Console.WriteLine("Invoking delegate d:"); d("D"); } }
Invoking delegate a: Hello, A! Invoking delegate b: Goodbye, B! Invoking delegate c: Hello, C! Goodbye, C! Invoking delegate d: Goodbye, D!
委託的聲明以下所示：
public delegate void Del<T>(T item); public void Notify(int i) { }
Del<int> d1 = new Del<int>(Notify);
在 C# 2.0 中，還可使用下面的簡化語法來聲明委託：
Del<int> d2 = Notify;
下面的示例闡釋聲明、實例化和使用委託。BookDB 類封裝一個書店數據庫，它維護一個書籍數據庫。它公開 ProcessPaperbackBooks 方法，該方法在數據庫中查找全部平裝書，並對每本平裝書調用一個委託。所使用的 delegate 類型稱爲 ProcessBookDelegate。Test 類使用該類輸出平裝書的書名和平均價格。
委託的使用促進了書店數據庫和客戶代碼之間功能的良好分隔。客戶代碼不知道書籍的存儲方式和書店代碼查找平裝書的方式。書店代碼也不知道找到平裝書後將對平裝書進行什麼處理。
// A set of classes for handling a bookstore: namespace Bookstore { using System.Collections; // Describes a book in the book list: public struct Book { public string Title; // Title of the book. public string Author; // Author of the book. public decimal Price; // Price of the book. public bool Paperback; // Is it paperback? public Book(string title, string author, decimal price, bool paperBack) { Title = title; Author = author; Price = price; Paperback = paperBack; } } // Declare a delegate type for processing a book: public delegate void ProcessBookDelegate(Book book); // Maintains a book database. public class BookDB { // List of all books in the database: ArrayList list = new ArrayList(); // Add a book to the database: public void AddBook(string title, string author, decimal price, bool paperBack) { list.Add(new Book(title, author, price, paperBack)); } // Call a passed-in delegate on each paperback book to process it: public void ProcessPaperbackBooks(ProcessBookDelegate processBook) { foreach (Book b in list) { if (b.Paperback) // Calling the delegate: processBook(b); } } } } // Using the Bookstore classes: namespace BookTestClient { using Bookstore; // Class to total and average prices of books: class PriceTotaller { int countBooks = 0; decimal priceBooks = 0.0m; internal void AddBookToTotal(Book book) { countBooks += 1; priceBooks += book.Price; } internal decimal AveragePrice() { return priceBooks / countBooks; } } // Class to test the book database: class TestBookDB { // Print the title of the book. static void PrintTitle(Book b) { System.Console.WriteLine(" {0}", b.Title); } // Execution starts here. static void Main() { BookDB bookDB = new BookDB(); // Initialize the database with some books: AddBooks(bookDB); // Print all the titles of paperbacks: System.Console.WriteLine("Paperback Book Titles:"); // Create a new delegate object associated with the static // method Test.PrintTitle: bookDB.ProcessPaperbackBooks(PrintTitle); // Get the average price of a paperback by using // a PriceTotaller object: PriceTotaller totaller = new PriceTotaller(); // Create a new delegate object associated with the nonstatic // method AddBookToTotal on the object totaller: bookDB.ProcessPaperbackBooks(totaller.AddBookToTotal); System.Console.WriteLine("Average Paperback Book Price: ${0:#.##}", totaller.AveragePrice()); } // Initialize the book database with some test books: static void AddBooks(BookDB bookDB) { bookDB.AddBook("The C Programming Language", "Brian W. Kernighan and Dennis M. Ritchie", 19.95m, true); bookDB.AddBook("The Unicode Standard 2.0", "The Unicode Consortium", 39.95m, true); bookDB.AddBook("The MS-DOS Encyclopedia", "Ray Duncan", 129.95m, false); bookDB.AddBook("Dogbert's Clues for the Clueless", "Scott Adams", 12.00m, true); } } }
Paperback Book Titles: The C Programming Language The Unicode Standard 2.0 Dogbert's Clues for the Clueless Average Paperback Book Price: $23.97
聲明委託。
下列語句：
public delegate void ProcessBookDelegate(Book book);
聲明一個新的委託類型。每一個委託類型都描述參數的數目和類型，以及它能夠封裝的方法的返回值類型。每當須要一組新的參數類型或新的返回值類型時，都必須聲明一個新的委託類型。
實例化委託。
聲明瞭委託類型後，必須建立委託對象並使之與特定方法關聯。在上面的示例中，這是經過將 PrintTitle 方法傳遞給 ProcessPaperbackBooks 方法來完成的，以下所示：
bookDB.ProcessPaperbackBooks(PrintTitle);
這將建立與靜態方法 Test.PrintTitle 關聯的新委託對象。相似地，對象 totaller 的非靜態方法 AddBookToTotal 是按以下方式傳遞的：
bookDB.ProcessPaperbackBooks(totaller.AddBookToTotal);
在兩個示例中，都向 ProcessPaperbackBooks 方法傳遞了一個新的委託對象。
委託一旦建立，它的關聯方法就不能更改；委託對象是不可變的。
調用委託。
建立委託對象後，一般將委託對象傳遞給將調用該委託的其餘代碼。經過委託對象的名稱（後面跟着要傳遞給委託的參數，括在括號內）調用委託對象。下面是委託調用的示例：
processBook(b);
與本例同樣，能夠經過使用 BeginInvoke 和 EndInvoke 方法同步或異步調用委託。