Meghatalmazott deklarálása, példányosítása és használata (C# programozási útmutató)

Deklarálhat meghatalmazottakat az alábbi módszerek bármelyikével:

• Deklaráljon egy delegálttípust, és deklaráljon egy metódust egyező aláírással:

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

• Metóduscsoport hozzárendelése meghatalmazotttípushoz:

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

• Névtelen metódus deklarálása:

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

• Lambda-kifejezés használata:

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

További információ: Lambda Expressions.

Az alábbi példa a deklarálást, a példányosítást és a meghatalmazott használatát mutatja be. Az BookDB osztály egy könyvesbolt adatbázist foglal magában, amely egy könyvadatbázist tart fenn. Egy metódust tesz elérhetővé, amely megkeresi az adatbázisban lévő összes papíralapú könyvet, ProcessPaperbackBooksés mindegyikhez meghív egy delegáltat. A delegate használt típus neve ProcessBookCallback. Az Test osztály ezzel az osztálysal nyomtatja ki a papíralapú könyvek címét és átlagos árát.

A meghatalmazottak használata elősegíti a funkciók megfelelő elkülönítését a könyvesbolt adatbázisa és az ügyfélkód között. Az ügyfélkód nem tudja, hogy a könyvek hogyan vannak tárolva, vagy hogy a könyvesbolt kódja hogyan találja meg a papíralapú könyveket. A könyvesbolt kódjának nincs ismerete arról, hogy milyen feldolgozást végeznek a papíralapú könyveken, miután megtalálta őket.

Példa

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

Robusztus programozás

• Meghatalmazott deklarálása.

  Az alábbi utasítás új meghatalmazotttípust deklarál.

  public delegate void ProcessBookCallback(Book book);
  

  Minden delegált típus az argumentumok számát és típusait, valamint a beágyazható metódusok visszatérési értékének típusát írja le. Amikor új argumentumtípusra vagy visszatérési értéktípusra van szükség, új deklarálási típust kell deklarálni.

• Meghatalmazott példányosítása.

  A delegált típus deklarálása után létre kell hozni egy delegált objektumot, és hozzá kell társítani egy adott metódust. Az előző példában ezt úgy teheti meg, hogy átadja a PrintTitle metódust a ProcessPaperbackBooks metódusnak, ahogyan az alábbi példában is látható:

  bookDB.ProcessPaperbackBooks(PrintTitle);
  

  Ezzel létrehoz egy új delegált objektumot, amely a statikus metódushoz Test.PrintTitlevan társítva. Hasonlóképpen, az objektum totaller nem statikus metódusa AddBookToTotal is át lesz adva az alábbi példához hasonlóan:

  bookDB.ProcessPaperbackBooks(totaller.AddBookToTotal);
  

  Mindkét esetben egy új delegált objektumot ad át a ProcessPaperbackBooks metódusnak.

  A meghatalmazott létrehozása után a metódus soha nem változik; a delegált objektumok nem módosíthatók.

• Meghatalmazott meghívása.

  A delegált objektum létrehozása után a delegált objektum általában más kódnak lesz átadva, amely meghívja a meghatalmazottat. A delegált objektum meghívása a delegált objektum nevével történik, majd a meghatalmazottnak átadandó zárójeles argumentumok. Az alábbi példa egy meghatalmazotti hívásra mutat be példát:

  processBook(b);
  

  A meghatalmazottak hívhatók szinkron módon, ahogyan ebben a példában is, vagy aszinkron módon, és metódusokkal BeginInvokeEndInvoke .

Lásd még

• Események
• Küldöttek