C#中的委托与事件[翻译]-.NET教程,C#语言

注意：委托以调用方的安全许可身份运行，而不是以声明方的许可运行。
    下面有两个委托的示例：
    例1向大家说明如何声明、实例化和调用一个委托；
    例2向大家说明如何联合两个委托。
例1
      这个例子说明如何声明、实例化和使用委托。bookdb类压缩了一个包含各种书籍的书店数据库，它对外暴露processpaperbackbooks方法，用以查找数据库中所有平装本的书籍并调用委托，使用委托来调用processbookdelegate。test类使用这个类来打印处平装本书籍的标题和平均价格。
     委托的使用促进了书店数据库与客户端代码之间功能性的良好分离。客户端代码不用知晓书是如何存的如何找到平装本，而书店的代码不用知道查找到该平装书并提供给客户端后将会被如何处理。代码如下（为了部影响理解，代码保持原样）：

  1// bookstore.cs
  2using system;
  3// a set of classes for handling a bookstore:
  4namespace bookstore 
  5{
  6   using system.collections;
  7   // describes a book in the book list:
  8   public struct book
  9   {
 10      public string title;        // title of the book.
 11      public string author;       // author of the book.
 12      public decimal price;       // price of the book.
 13      public bool paperback;      // is it paperback?
 14      public book(string title, string author, decimal price, bool paperback)
 15      {
 16         title = title;
 17         author = author;
 18         price = price;
 19         paperback = paperback;
 20      }
 21   }
 22
 23   // declare a delegate type for processing a book:
 24   public delegate void processbookdelegate(book book);
 25
 26   // maintains a book database.
 27   public class bookdb
 28   {
 29      // list of all books in the database:
 30      arraylist list = new arraylist();   
 31
 32      // add a book to the database:
 33      public void addbook(string title, string author, decimal price, bool paperback)
 34      {
 35         list.add(new book(title, author, price, paperback));
 36      }
 37
 38      // call a passed-in delegate on each paperback book to process it: 
 39      public void processpaperbackbooks(processbookdelegate processbook)
 40      {
 41        foreach (book b in list) 
 42         {
 43            if (b.paperback)
 44
 45            // calling the delegate:
 46               processbook(b);
 47         }
 48      }
 49   }
 50}
 51// using the bookstore classes:
 52namespace booktestclient
 53{
 54   using bookstore;
 55
 56   // class to total and average prices of books:
 57   class pricetotaller
 58   {
 59      int countbooks = 0;
 60      decimal pricebooks = 0.0m;
 61      internal void addbooktototal(book book)
 62      {
 63         countbooks += 1;
 64         pricebooks += book.price;
 65      }
 66      internal decimal averageprice()
 67      {
 68         return pricebooks / countbooks;
 69      }
 70   }
 71   // class to test the book database:
 72   class test
 73   {
 74      // print the title of the book.
 75      static void printtitle(book b)
 76      {
 77         console.writeline(”   {0}”, b.title);
 78      }
 79      // execution starts here.
 80      static void main()
 81      {
 82         bookdb bookdb = new bookdb();
 83         // initialize the database with some books:
 84         addbooks(bookdb);      
 85         // print all the titles of paperbacks:
 86         console.writeline(“paperback book titles:”);
 87         // create a new delegate object associated with the static 
 88         // method test.printtitle:
 89         bookdb.processpaperbackbooks(new processbookdelegate(printtitle));
 90         // get the average price of a paperback by using
 91         // a pricetotaller object:
 92         pricetotaller totaller = new pricetotaller();
 93         // create a new delegate object associated with the nonstatic 
 94         // method addbooktototal on the object totaller:
 95         bookdb.processpaperbackbooks(new processbookdelegate(totaller.addbooktototal));
 96         console.writeline(“average paperback book price: ${0:#.##}”,
 97            totaller.averageprice());
 98      }
 99      // initialize the book database with some test books:
100      static void addbooks(bookdb bookdb)
101      {
102         bookdb.addbook(“the c programming language”, 
103            “brian w. kernighan and dennis m. ritchie”, 19.95m, true);
104         bookdb.addbook(“the unicode standard 2.0”, 
105            “the unicode consortium”, 39.95m, true);
106         bookdb.addbook(“the ms-dos encyclopedia”, 
107            “ray duncan”, 129.95m, false);
108         bookdb.addbook(“dogberts clues for the clueless”, 
109            “scott adams”, 12.00m, true);
110      }
111   }
112}
113

输出：

    平装书的标题：

   the c programming language
    the unicode standard 2.0

    dogberts clues for the clueless

平均价格: $23.97

委托的声明

委托可声明如下:
public delegate void processbookdelegate(book book);

声明一个新的委托类型。每个委托类型可包含委托描述的数量和类型，包含被压缩方法返回值的类型。不管是否需要一组类型描述或返回值类型，必须声明一个新的委托类型。

实例化一个委托: 挡一个委托的类型被声明后，必须创建委托对象并与一个特定的方法相关联。和其他对象一样，需要一起创建新的委托对象和新的表达式。

看看这段:
bookdb.processpaperbackbooks(new processbookdelegate(printtitle));

声明一个关联静态方法test.printtitle的委托对象。
再看看这段:
bookdb.processpaperbackbooks(new processbookdelegate(totaller.addbooktototal));

创建一个委托对象关联totaller对象上的非静态方法 addbooktototal。新的委托对象马上被传递给processpaperbackbooks方法。

请注意，委托一旦被创建后，其关联的方法将不能再被更改，因为委托对象是不可变的。

调用委托:委托对象被创建后会被传递给调用委托的其他代码。通过委托对象名称和其后跟随的括号化描述来调用委托对象，示例如下。

processbook(b);

如例中所示，委托可以被同步调用，也可以使用begininvoke和endinvoke异步调用。

例2（示范如何联合两个委托）

这个例子示范了委托的构成，委托对象的一个有用属性是他们可以使用”+”运算符来进行联合，联合委托调用组成它的两个委托，只有类型相同的委托才可以联合。”－”操作符用于从联合委托中移除一个委托。示例代码如下：
 

 1// compose.cs
 2using system;
 3delegate void mydelegate(string s);
 4class myclass
 5{
 6    public static void hello(string s)
 7    {
 8        console.writeline(”  hello, {0}!”, s);
 9    }
10    public static void goodbye(string s)
11    {
12        console.writeline(”  goodbye, {0}!”, s);
13    }
14    public static void main()
15    {
16        mydelegate a, b, c, d;
17        // create the delegate object a that references 
18        // the method hello:
19        a = new mydelegate(hello);
20        // create the delegate object b that references 
21        // the method goodbye:
22        b = new mydelegate(goodbye);
23        // the two delegates, a and b, are composed to form c: 
24        c = a + b;
25        // remove a from the composed delegate, leaving d, 
26        // which calls only the method goodbye:
27        d = c – a;
28        console.writeline(“invoking delegate a:”);
29        a(“a”);
30        console.writeline(“invoking delegate b:”);
31        b(“b”);
32        console.writeline(“invoking delegate c:”);
33        c(“c”);
34        console.writeline(“invoking delegate d:”);
35        d(“d”);
36    }
37}
38

调用委托 a:
  hello, a!
调用委托b:
  goodbye, b!
调用委托c:
  hello, c!
  goodbye, c!
调用委托d:
  goodbye, d!

      对于给组件的“听众”来通知该组件的发生的事件而言，使用委托特别适合。

委托 vs. 接口

    委托与接口在都能促成规范与执行的分离，有相似之处。那声明时候使用委托声明时候使用接口呢？大体依据以下原则：

如下情况宜使用委托:

如下情况宜使用接口：