(0) exportieren Drucken
Alle erweitern

Gewusst wie: Deklarieren, Instanziieren und Verwenden von Delegaten (C#-Programmierhandbuch)

Aktualisiert: November 2007

In C# 1.0 und höher können Delegaten wie folgt deklariert werden:

public delegate void Del<T>(T item);
public void Notify(int i) { }


Del<int> d1 = new Del<int>(Notify);


In C# 2.0 und höher ist es auch möglich, unter Verwendung einer anonymen Methode einen Delegaten mit der folgenden vereinfachten Syntax zu deklarieren und zu initialisieren:

Del<int> d2 = Notify;


In C# 3.0 und höher können Delegaten auch mithilfe von Lambda-Ausdrücken deklariert und instanziiert werden. Weitere Informationen finden Sie unter Lambda-Ausdrücke (C#-Programmierhandbuch).

Im folgenden Beispiel wird verdeutlicht, wie Sie einen Delegaten deklarieren, instanziieren und verwenden. In der BookDB-Klasse ist eine Buchhandlungsdatenbank gekapselt, die eine Buchtiteldatenbank enthält. Sie stellt eine ProcessPaperbackBooks-Methode zur Verfügung, durch die alle Taschenbücher in der Datenbank gefunden und für jedes Taschenbuch ein Delegat aufgerufen wird. Der verwendete delegate-Typ hat den Namen ProcessBookDelegate. Die Test-Klasse verwendet diese Klasse, um die Buchtitel und Durchschnittspreise der Taschenbücher auszugeben.

Die Verwendung von Delegaten beinhaltet eine sinnvolle Trennung der Funktionalitäten von Buchhandlungsdatenbank und Clientcode. Der Clientcode weiß nicht, wie die Bücher archiviert werden oder wie der Buchhandlungscode Taschenbücher sucht. Der Buchhandlungscode wiederum weiß nicht, wie ein Taschenbuchtitel weiterverarbeitet wird, nachdem er gefunden wurde.

// 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
*/


  • Deklarieren von Delegaten

    Mit der folgenden Anweisung wird ein neuer Delegattyp deklariert.

    public delegate void ProcessBookDelegate(Book book);
    
    
    

    Durch die einzelnen Delegattypen werden Anzahl und Typen von Argumenten sowie Rückgabewerte von Methoden beschrieben, die gekapselt können. Sobald neue Argumenttypen oder ein neuer Rückgabewerttyp erforderlich ist, muss ein neuer Delegattyp deklariert werden.

  • Instanziieren von Delegaten

    Nachdem ein Delegattyp deklariert wurde, muss ein Delegatobjekt erstellt und mit einer bestimmten Methode verknüpft werden. Im vorherigen Beispiel übergeben Sie dazu die PrintTitle-Methode an die ProcessPaperbackBooks-Methode, wie im folgenden Beispiel gezeigt:

    bookDB.ProcessPaperbackBooks(PrintTitle);
    
    
    

    Hierdurch wird ein neues Delegatobjekt erstellt, das mit der static-Methode verknüpft ist Test.PrintTitle. Auf ähnliche Weise wird die nicht statische AddBookToTotal-Methode für das totaller-Objekt wie im folgenden Beispiel übergeben:

    bookDB.ProcessPaperbackBooks(totaller.AddBookToTotal);
    
    
    

    In beiden Fällen wird ein neues Delegatobjekt an die ProcessPaperbackBooks-Methode übergeben.

    Nach der Erstellung eines Delegaten wird die mit diesem verknüpfte Methode nicht mehr geändert. Delegatobjekte sind unveränderlich.

  • Aufrufen von Delegaten

    Nachdem ein Delegatobjekt erstellt wurde, wird es normalerweise an anderen Code übergeben, durch den der Delegat aufgerufen wird. Ein Delegatobjekt wird über seinen Namen aufgerufen. Auf den Namen folgen (in Klammern gesetzte) Argumente, die an den Delegaten übergeben werden sollen. Es folgt ein Beispiel für einen Delegataufruf:

    processBook(b);
    
    
    

    Ein Delegat kann entweder (wie in diesem Beispiel) synchron oder mithilfe der BeginInvoke-Methode und der EndInvoke-Methode asynchron aufgerufen werden.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft