Cara mendeklarasikan, membuat instans, dan menggunakan Delegasi (Panduan Pemrograman C#)

Artikel
04/07/2023

Anda dapat mendeklarasikan delegasi menggunakan salah satu metode berikut:

Nyatakan jenis delegasi dan deklarasikan metode dengan tanda tangan yang cocok:

// Declare a delegate.
delegate void NotifyCallback(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.
NotifyCallback del1 = new NotifyCallback(Notify);

Tetapkan grup metode ke jenis delegasi:

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

Deklarasikan metode anonim:

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

Gunakan ekspresi lambda:

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

Untuk informasi selengkapnya, lihat Ekspresi Lambda.

Contoh berikut mengilustrasikan mendeklarasikan, membuat instans, dan menggunakan delegasi. Kelas BookDB ini merangkum database bookstore yang mempertahankan database buku. Ini mengekspos metode, ProcessPaperbackBooks, yang menemukan semua buku paperback dalam database dan memanggil delegasi untuk masing-masing buku. Jenis delegate yang digunakan diberi nama ProcessBookCallback. Kelas Test ini menggunakan kelas ini untuk mencetak judul dan harga rata-rata buku paperback.

Penggunaan delegasi mempromosikan pemisahan fungsionalitas yang baik antara database bookstore dan kode klien. Kode klien tidak memiliki pengetahuan tentang bagaimana buku disimpan atau bagaimana kode toko buku menemukan buku paperback. Kode bookstore tidak memiliki pengetahuan tentang pemrosesan apa yang dilakukan pada buku paperback setelah menemukannya.

Contoh

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

Pemrograman yang Kuat

Mendeklarasikan delegasi.

Pernyataan berikut mendeklarasikan jenis delegasi baru.
```
public delegate void ProcessBookCallback(Book book);
```
Setiap jenis delegasi menjelaskan jumlah dan jenis argumen, dan jenis nilai pengembalian metode yang dapat dienkapsulasi. Setiap kali set baru jenis argumen atau jenis nilai pengembalian diperlukan, jenis delegasi baru harus dideklarasikan.
Membuat instans delegasi.

Setelah jenis delegasi dinyatakan, objek delegasi harus dibuat dan dikaitkan dengan metode tertentu. Dalam contoh sebelumnya, Anda melakukan ini dengan meneruskan metode PrintTitle ke metode ProcessPaperbackBooks seperti dalam contoh berikut:
```
bookDB.ProcessPaperbackBooks(PrintTitle);
```
Ini membuat objek delegasi baru yang terkait dengan metode statis Test.PrintTitle. Demikian pula, metode AddBookToTotal non-statis pada objek totaller diteruskan seperti dalam contoh berikut:
```
bookDB.ProcessPaperbackBooks(totaller.AddBookToTotal);
```
Dalam kedua kasus, objek delegasi baru diteruskan ke metode ProcessPaperbackBooks.

Setelah delegasi dibuat, metode yang terkait dengannya tidak pernah berubah; objek delegasi tidak dapat diubah.
Memanggil delegasi.

Setelah objek delegasi dibuat, objek delegasi biasanya diteruskan ke kode lain yang akan memanggil delegasi. Objek delegasi dipanggil dengan menggunakan nama objek delegasi, diikuti oleh argumen di dalam kurung untuk diteruskan ke delegasi. Berikut ini adalah contoh panggilan delegasi:
```
processBook(b);
```
Delegasi dapat dipanggil secara sinkron, seperti dalam contoh ini, atau secara asinkron dengan menggunakan metode BeginInvoke dan EndInvoke.

Bagikan melalui

Cara mendeklarasikan, membuat instans, dan menggunakan Delegasi (Panduan Pemrograman C#)

Contoh

Pemrograman yang Kuat

Lihat juga

Sumber Daya Tambahan: