Bagikan melalui

Delegasi dengan Method Bernama vs. Method Anonim (Panduan Pemrograman C#)

Sebuah delegasi dapat dikaitkan dengan method bernama. Saat Anda membuat instance delegasi dengan menggunakan method bernama, method diteruskan sebagai parameter, misalnya:

// Declare a delegate.
delegate void WorkCallback(int x);

// Define a named method.
void DoWork(int k) { /* ... */ }

// Instantiate the delegate using the method as a parameter.
WorkCallback d = obj.DoWork;

Contoh sebelumnya menggunakan metode yang dinamai. Delegasi yang dibangun dengan method bernama dapat merangkum method statis atau method instance. Method bernama adalah satu-satunya cara untuk membuat instance delegasi di versi C#sebelumnya. C# memungkinkan Anda membuat instans delegasi dan segera menentukan blok kode yang diproses delegasi saat dipanggil. Blok dapat berisi ekspresi lambda atau metode anonim, seperti yang ditunjukkan dalam contoh berikut:

// Declare a delegate.
delegate void WorkCallback(int x);

// Instantiate the delegate using an anonymous method.
WorkCallback d = (int k) => { /* ... */ };

Method yang Anda berikan sebagai parameter delegasi harus memiliki signature yang sama dengan deklarasi delegasi. Instans delegasi dapat merangkum metode statis atau instans.

Catatan

Meskipun delegasi dapat menggunakan sebuah parameter keluar, kami tidak merekomendasikan penggunaannya dengan delegasi multicast event karena Anda tidak dapat mengetahui delegasi mana yang akan dipanggil.

Grup metode dengan kelebihan beban tunggal memiliki jenis alami. Pengkompilasi dapat menyimpulkan jenis pengembalian dan jenis parameter untuk jenis delegasi:

var read = Console.Read; // Just one overload; Func<int> inferred
var write = Console.Write; // ERROR: Multiple overloads, can't choose

Contoh

Contoh berikut adalah contoh sederhana untuk mendeklarasikan dan menggunakan delegasi. Perhatikan bahwa kedua delegasi, MultiplyCallback, dan method terkait, MultiplyNumbers, memiliki signature yang sama

// Declare a delegate
delegate void MultiplyCallback(int i, double j);

class MathClass
{
    static void Main()
    {
        MathClass m = new MathClass();

        // Delegate instantiation using "MultiplyNumbers"
        MultiplyCallback d = m.MultiplyNumbers;

        // Invoke the delegate object.
        Console.WriteLine("Invoking the delegate using 'MultiplyNumbers':");
        for (int i = 1; i <= 5; i++)
        {
            d(i, 2);
        }

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }

    // Declare the associated method.
    void MultiplyNumbers(int m, double n)
    {
        Console.Write(m * n + " ");
    }
}
/* Output:
    Invoking the delegate using 'MultiplyNumbers':
    2 4 6 8 10
*/

Dalam contoh berikut, satu delegasi dipetakan ke method statis dan method instance dan mengembalikan informasi tertentu dari masing-masing.

// Declare a delegate
delegate void Callback();

class SampleClass
{
    public void InstanceMethod()
    {
        Console.WriteLine("A message from the instance method.");
    }

    static public void StaticMethod()
    {
        Console.WriteLine("A message from the static method.");
    }
}

class TestSampleClass
{
    static void Main()
    {
        var sc = new SampleClass();

        // Map the delegate to the instance method:
        Callback d = sc.InstanceMethod;
        d();

        // Map to the static method:
        d = SampleClass.StaticMethod;
        d();
    }
}
/* Output:
    A message from the instance method.
    A message from the static method.
*/

Lihat juga

  • Last updated on