Diese Dokumentation wurde archiviert und wird nicht länger gepflegt.

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

Delegaten werden wie folgt deklariert:

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

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

In C# 2.0 ist es auch möglich, einen Delegaten mit dieser vereinfachten Syntax zu deklarieren:

Del<int> d2 = Notify;

Im folgenden Beispiel wird verdeutlicht, wie Sie einen Delegaten deklarieren, instanziieren und verwenden. In der BookDB-Klasse ist eine Buchhandlungsdatenbank eingeschlossen, 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 zur Ausgabe der Buchtitel und Durchschnittspreise der Taschenbücher.

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.

Beispiel

// 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);
        }
    }
}

Ausgabe

Paperback Book Titles:
   The C Programming Language
   The Unicode Standard 2.0
   Dogbert's Clues for the Clueless
Average Paperback Book Price: $23.97

Robuste Programmierung

  • Deklarieren von Delegaten

    Durch die Anweisung

    public delegate void ProcessBookDelegate(Book book);
    
    

    wird ein neuer Delegattyp deklariert. Durch die einzelnen Delegattypen werden Anzahl und Typen von Argumenten sowie Rückgabewerte von Methoden beschrieben, die eingeschlossen werden 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 obigen Beispiel geschieht dies, indem die PrintTitle-Methode an die ProcessPaperbackBooks-Methode übergeben wird:

    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 wie folgt an das totaller-Objekt ü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. 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.

Siehe auch

Anzeigen: