Como: Declarar, instanciar e usar um delegado (guia de programação translation from VPE for Csharp)
Em translation from VPE for Csharp 1.0 e posterior, delegados podem ser declarados sistema autônomo mostrado aqui:
public delegate void Del<T>(T item);
public void Notify(int i) { }
Del<int> d1 = new Del<int>(Notify);
Na translation from VPE for Csharp 2.0 e posteriores, também é possível usar um método anônimo para declarar e inicializar um delegado usando esse simplificado sintaxe:
Del<int> d2 = Notify;
Em translation from VPE for Csharp 3.0 e posterior, delegados também podem ser declarados e instanciados usando uma expressão lambda.Para obter mais informações, consulte Expressões lambda (guia de programação translation from VPE for Csharp).
O exemplo a seguir ilustra a declarar, instanciar e usar um delegado.The BookDB classe encapsula um banco de dados da livraria que mantém um banco de dados de livros. Ela expõe um método, ProcessPaperbackBooks, que localiza papel jornal todos os livros no banco de dados e chama um delegado para cada um deles. The delegate tipo usado é denominado ProcessBookDelegate. The Test classe usa essa classe para imprimir os títulos e o preço médio dos registros de bolso.
O uso de delegates promove mercadoria separação de funcionalidade entre o banco de dados livraria e o código do cliente.O código do cliente não tem conhecimento de como os catálogos são armazenados ou como o código livraria encontra livros de bolso.O código da livraria não tem conhecimento de qual processamento é realizado no bolso livros após encontra.
Exemplo
// 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);
}
}
}
/* 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
*/
Programação robusta
Declarar um delegado.
A demonstrativo a seguir declara um novo tipo de delegado.
public delegate void ProcessBookDelegate(Book book);Cada tipo de delegado descreve o número e tipos dos argumentos e o tipo do valor retornado de métodos que pode encapsular.Sempre que for necessário um novo conjunto de tipos de argumento ou tipo de valor retornado, um novo tipo de delegado deve ser declarado.
Criar uma instância de um delegado.
Após ter sido declarado um tipo delegado, um objeto delegado deve ser criado e associado a um método específico.No exemplo anterior, isso é feito, passando o PrintTitle método para o ProcessPaperbackBooks método sistema autônomo no exemplo a seguir:
bookDB.ProcessPaperbackBooks(PrintTitle);Isso cria um novo objeto de delegado associado com o estático método Test.PrintTitle. Da mesma forma, o método não estático AddBookToTotal no objeto totaller é passado sistema autônomo no exemplo a seguir:
bookDB.ProcessPaperbackBooks(totaller.AddBookToTotal);Ambos os casos, um novo objeto delegado é passado para o ProcessPaperbackBooks método.
Após a criação de um delegado, o método está associado nunca alterações; delegado objetos são imutáveis.
Chamar um delegado.
Após a criação de um objeto delegado, o objeto delegado normalmente é passado para Outros código que irá chamar o delegado.Um objeto delegado é chamado usando o nome do objeto delegado, seguido pelos argumentos entre parênteses a ser passada para o delegado.A seguir é um exemplo de uma telefonar de delegado:
processBook(b);Um delegado pode ser que um chamado sincronicamente, sistema autônomo no exemplo, ou assincronamente usando BeginInvoke e EndInvoke métodos.