C#——声明、实例化和使用委托

本是古典何须时尚 2023-01-03 04:22 127阅读 0赞

## C\#——声明、实例化和使用委托 ##

在 C\# 1.0 和更高版本中，可以如下面的示例所示声明委托。

// Declare a delegate.
    delegate void Del(string str);
    
    // Declare a method with the same signature as the delegate.
    static void Notify(string name)
    {
        
        Console.WriteLine($"Notification received for: {name}");
    }

// Create an instance of the delegate.
    Del del1 = new Del(Notify);

C\# 2.0 提供了更简单的方法来编写前面的声明，如下面的示例所示。

// C# 2.0 provides a simpler way to declare an instance of Del.
    Del del2 = Notify;

在 C\# 2.0 和更高版本中，还可以使用匿名方法来声明和初始化委托，如下面的示例所示。

// Instantiate Del by using an anonymous method.
    Del del3 = delegate(string name)
        {
         Console.WriteLine($"Notification received for: {name}"); };

在 C\# 3.0 和更高版本中，还可以通过使用 lambda 表达式声明和实例化委托，如下面的示例所示。

// Instantiate Del by using a lambda expression.
    Del del4 = name =>  {
         Console.WriteLine($"Notification received for: {name}"); };

下面的示例演示如何声明、实例化和使用委托。 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 Test
        {
        
            // Print the title of the book.
            static void PrintTitle(Book b)
            {
        
                Console.WriteLine($"   {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:
                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);
    
                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);
            }
        }
    }
    /* Output:
    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);