Bagian 1: Pendahuluan

Apa itu Delegate?

Delegate adalah tipe data referensi di C# yang menyimpan referensi ke sebuah method, alih-alih menyimpan nilai atau objek biasa. Karena Delegate menyimpan referensi ke method, ia memungkinkan sebuah method diperlakukan sebagai data yang bisa disimpan dalam variabel, dikirim sebagai parameter, dikembalikan dari method lain, atau dipanggil secara dinamis pada saat runtime.

Secara sederhana, jika biasanya sebuah variabel menyimpan angka, string, atau objek, maka Delegate menyimpan "alamat" dari sebuah method beserta signature-nya (tipe parameter dan tipe return value). Selama sebuah method memiliki signature yang cocok dengan Delegate tersebut, method itu bisa "dititipkan" ke dalam instance Delegate dan dipanggil kapan saja melalui instance tersebut.

Contoh sederhana:

public delegate void Notify(string message);

public class Program
{
    public static void SendEmail(string message)
    {
        Console.WriteLine($"Email sent: {message}");
    }

    public static void Main()
    {
        Notify notify = SendEmail;
        notify("Order has been placed.");
    }
}

Pada contoh di atas, Notify adalah tipe Delegate yang mendefinisikan signature: menerima satu parameter string dan tidak mengembalikan nilai (void). Method SendEmail memiliki signature yang cocok, sehingga bisa ditugaskan ke variabel notify dan dipanggil layaknya memanggil method biasa.

Mengapa Delegate Dibuat?

Delegate diciptakan untuk menjawab kebutuhan agar method bisa diperlakukan sebagai first-class citizen, sama seperti variabel pada umumnya. Tanpa Delegate, sebuah class hanya bisa memanggil method yang sudah ia ketahui secara langsung pada saat compile time, sehingga perilaku suatu komponen menjadi kaku dan sulit diperluas tanpa mengubah kode sumbernya.

Beberapa alasan mendasar mengapa Delegate dibutuhkan dalam desain bahasa C#:

• Memungkinkan callback, yaitu memberi tahu kode pemanggil (caller) untuk menjalankan sebuah method tertentu setelah suatu proses selesai, tanpa caller tersebut perlu tahu detail implementasinya.
• Menjadi dasar bagi mekanisme event, yang banyak dipakai dalam pemrograman GUI dan arsitektur publisher-subscriber.
• Mendukung Higher Order Function, yaitu method yang menerima method lain sebagai parameter atau mengembalikan method sebagai hasilnya.
• Memberi fleksibilitas untuk menukar perilaku (behavior) suatu komponen pada saat runtime, tanpa mengubah struktur class yang sudah ada, sehingga selaras dengan prinsip Open/Closed dalam SOLID.

Sejarah Delegate di C#

Delegate sudah hadir sejak C# versi pertama (.NET Framework 1.0) dan menjadi salah satu fitur inti yang membedakan C# dari bahasa seperti Java pada masa itu, yang belum memiliki konsep function pointer yang aman secara tipe (type-safe). Desain awal Delegate terinspirasi dari konsep function pointer pada C dan C++, tetapi dibuat lebih aman karena Delegate di C# bersifat strongly typed, sehingga compiler dapat memverifikasi kecocokan signature sebelum program dijalankan.

Pada masa awal, penggunaan Delegate cenderung verbose karena harus dideklarasikan secara eksplisit menggunakan kata kunci delegate dan diberi nama method secara langsung. Seiring waktu, C# terus menambahkan sintaks yang menyederhanakan cara membuat dan menggunakan Delegate.

Evolusi Delegate hingga C# Terbaru

Beberapa titik penting evolusi Delegate sepanjang perkembangan C#:

• C# 1.0: Delegate diperkenalkan dengan sintaks eksplisit menggunakan kata kunci delegate, hanya bisa diisi dengan named method.
• C# 2.0: Diperkenalkan Anonymous Method menggunakan kata kunci delegate { ... }, sehingga method tidak perlu dideklarasikan terpisah. Generic Delegate juga mulai didukung penuh berkat generic type di C# 2.0.
• C# 3.0: Lambda Expression diperkenalkan dengan operator =>, menggantikan sebagian besar penggunaan Anonymous Method karena lebih ringkas. Pada versi ini pula tipe Delegate bawaan seperti Func dan Action mulai diperluas penggunaannya, didukung oleh LINQ yang bergantung besar pada Delegate.
• C# 5.0 ke atas: Delegate mulai berdampingan dengan async/await, memunculkan pola seperti Func<Task> dan Action versi asynchronous.
• C# terbaru (mendekati C# 12-13): Delegate tetap menjadi fondasi penting, terutama dengan semakin banyaknya static lambda dan optimisasi allocation, di mana compiler dan runtime terus disempurnakan agar penggunaan Delegate lebih efisien dari sisi memori dan performa.

Delegate Sebelum Lambda Expression

Sebelum Lambda Expression hadir di C# 3.0, penggunaan Delegate memerlukan salah satu dari dua pendekatan berikut:

1. Pendekatan pertama menggunakan named method:

   C#

   public delegate int Calculate(int a, int b);
   
   public class MathOperations
   {
       public static int Add(int a, int b) => a + b;
   }
   
   public class Program
   {
       public static void Main()
       {
           Calculate calculate = new Calculate(MathOperations.Add);
           int result = calculate(5, 3);
           Console.WriteLine(result);
       }
   }

2. Pendekatan kedua menggunakan Anonymous Method yang diperkenalkan pada C# 2.0:

   C#

   Calculate calculate = delegate (int a, int b)
   {
       return a + b;
   };
   
   int result = calculate(5, 3);

Kedua pendekatan ini terasa cukup verbose, terutama saat digunakan berulang kali untuk logika-logika sederhana.

Delegate Setelah Lambda Expression

Sejak C# 3.0, Lambda Expression menjadi cara yang jauh lebih ringkas untuk membuat instance Delegate tanpa perlu mendefinisikan method terpisah maupun menulis kata kunci delegate secara eksplisit.

Calculate calculate = (a, b) => a + b;
int result = calculate(5, 3);

Dengan hadirnya Lambda Expression, penggunaan Delegate menjadi jauh lebih natural, terutama ketika dipakai bersama tipe Delegate generic bawaan seperti Func<T, TResult>, Action<T>, dan Predicate<T>, yang akan dibahas lebih dalam pada bagian-bagian selanjutnya. Lambda Expression juga menjadi fondasi penting bagi LINQ, karena hampir seluruh operator LINQ seperti Where, Select, dan OrderBy menerima Delegate sebagai parameter, dan Lambda Expression menjadi cara paling umum untuk mengisinya.

Bagian 2: Konsep Dasar Delegate

Method sebagai First-Class Object

Dalam banyak bahasa pemrograman fungsional, method atau fungsi bisa diperlakukan sebagai objek biasa: disimpan dalam variabel, dikirim sebagai argumen, dan dikembalikan sebagai hasil dari fungsi lain. Konsep ini disebut first-class function atau first-class citizen.

C# adalah bahasa yang berbasis object-oriented, sehingga method secara alami terikat pada class atau struct tempat ia didefinisikan dan tidak bisa berdiri sendiri sebagai nilai. Delegate hadir sebagai jembatan yang membuat method di C# bisa diperlakukan layaknya first-class object, tanpa mengubah fondasi object-oriented dari bahasa itu sendiri. Delegate pada dasarnya adalah sebuah class khusus yang dibuat oleh compiler, yang tugasnya membungkus referensi ke method (dan, jika diperlukan, referensi ke instance objeknya) sehingga bisa diperlakukan seperti objek pada umumnya.

Dengan Delegate, sebuah method bisa:

• Disimpan dalam variabel, seperti Calculate calc = Add;
• Dikirim sebagai parameter ke method lain, seperti ProcessData(data, Validate);
• Dikembalikan sebagai hasil dari sebuah method, seperti GetValidator()
• Disimpan dalam struktur data seperti array atau List<T>

Function Pointer pada Bahasa Lain

Konsep menyimpan "alamat" sebuah fungsi bukan hal baru; bahasa seperti C dan C++ sudah lama memiliki function pointer. Namun function pointer pada C/C++ bekerja pada level yang sangat rendah: ia hanya menyimpan alamat memori dari fungsi, tanpa jaminan bahwa signature-nya benar-benar cocok pada saat runtime. Kesalahan pada function pointer sering kali baru terlihat saat program crash, karena compiler tidak selalu bisa memverifikasi kecocokan tipe secara ketat.

Contoh function pointer pada C, sebagai pembanding konsep:

int add(int a, int b) {
    return a + b;
}

int (*operation)(int, int) = add;
int result = operation(5, 3);

Delegate di C# mengambil ide dasar yang sama, yaitu menyimpan referensi ke fungsi, tetapi dibungkus dengan keamanan tipe (type safety) penuh dari CLR (Common Language Runtime). Setiap Delegate memiliki signature yang jelas, sehingga compiler akan menolak penugasan method yang signature-nya tidak cocok, jauh sebelum program dijalankan.

Bahasa lain seperti Java secara historis tidak memiliki function pointer maupun Delegate; sebagai gantinya Java mengandalkan interface dengan satu method (yang belakangan disebut functional interface) untuk mencapai efek serupa, baru diperkenalkan secara lebih ringkas melalui Lambda Expression pada Java 8.

Bagaimana C# Mengimplementasikan Delegate

Secara internal, setiap kali kita mendeklarasikan sebuah tipe Delegate menggunakan kata kunci delegate, compiler C# sebenarnya menghasilkan sebuah class baru yang secara implisit mewarisi dari System.MulticastDelegate (yang pada gilirannya mewarisi dari System.Delegate). Class ini dibuat otomatis oleh compiler; kita sebagai developer tidak perlu (dan tidak bisa) menulis class tersebut secara manual.

Contoh deklarasi:

public delegate int Calculate(int a, int b);

Baris di atas, jika dikompilasi, kurang lebih setara secara konsep dengan class berikut:

public sealed class Calculate : System.MulticastDelegate
{
    public Calculate(object target, IntPtr method) { /* implementasi internal CLR */ }

    public int Invoke(int a, int b) { /* implementasi internal CLR */ }

    public IAsyncResult BeginInvoke(int a, int b, AsyncCallback callback, object state) { /* ... */ }

    public int EndInvoke(IAsyncResult result) { /* ... */ }
}

Class hasil generate ini otomatis memiliki beberapa method penting:

• Constructor, yang menerima target objek (jika method-nya adalah instance method) dan pointer ke method.
• Invoke, method yang dipanggil saat kita "memanggil" Delegate seperti memanggil fungsi biasa.
• BeginInvoke dan EndInvoke, yang mendukung pemanggilan method secara asynchronous menggunakan pola lama (akan dibahas lebih lanjut pada Bagian 22).

Cara Kerja Delegate

Ketika sebuah method ditugaskan ke Delegate, ada dua informasi penting yang disimpan oleh instance Delegate tersebut:

1. Method pointer, yaitu referensi ke lokasi method yang akan dijalankan.
2. Target object, yaitu referensi ke instance objek tempat method tersebut berada — hanya relevan jika method yang ditugaskan adalah instance method, bukan static method.

Ketika Delegate dipanggil (di-invoke), CLR akan menggunakan kedua informasi tersebut untuk menentukan method mana yang harus dijalankan, dan pada instance objek yang mana (jika diperlukan).

public class OrderService
{
    public void ProcessOrder(string orderId)
    {
        Console.WriteLine($"Processing order {orderId}");
    }
}

public delegate void OrderHandler(string orderId);

public class Program
{
    public static void Main()
    {
        var service = new OrderService();
        OrderHandler handler = service.ProcessOrder;

        handler("ORD-001");
    }
}

Pada contoh di atas, handler menyimpan referensi ke method ProcessOrder sekaligus referensi ke instance service. Saat handler("ORD-001") dipanggil, CLR akan memanggil service.ProcessOrder("ORD-001") di balik layar.

Memory Model Delegate

Dari sisi memori, instance Delegate adalah objek yang dialokasikan di heap, sama seperti objek class pada umumnya, karena Delegate memang merupakan reference type. Setiap instance Delegate menyimpan sebuah invocation list, yaitu daftar pasangan (target object, method pointer) yang akan dipanggil saat Delegate tersebut di-invoke.

Untuk Delegate yang hanya menyimpan satu method (singlecast), invocation list ini hanya berisi satu entri. Namun Delegate di C# secara default sebenarnya selalu bersifat multicast, sehingga invocation list-nya bisa berisi lebih dari satu entri apabila beberapa method digabungkan menggunakan operator += (dibahas lebih dalam pada Bagian 6).

Beberapa implikasi penting dari memory model ini:

• Setiap kali sebuah lambda expression atau anonymous method yang meng-capture variabel dari luar dibuat, C# akan mengalokasikan objek closure tambahan di heap untuk menyimpan variabel yang di-capture tersebut, sehingga bisa berdampak pada performa apabila dilakukan berulang kali dalam loop atau hot path (akan dibahas lebih detail pada Bagian 32 tentang Performance).
• Karena Delegate adalah reference type, dua instance Delegate yang menyimpan method dan target yang sama tetap dianggap setara (equal) secara nilai, berkat override Equals pada System.Delegate yang membandingkan target dan method pointer, bukan alamat objek Delegate itu sendiri.
• Delegate yang menyimpan referensi ke instance object dapat secara tidak sengaja mencegah objek tersebut dibersihkan oleh Garbage Collector selama Delegate itu masih direferensikan oleh pihak lain, sebuah isu yang sering muncul dalam penggunaan Event dan akan dibahas pada Bagian 31 mengenai Anti Pattern.

Bagian 3: Deklarasi Delegate

Syntax

Deklarasi Delegate di C# menggunakan kata kunci delegate, diikuti dengan return type, nama tipe Delegate, dan daftar parameter, mirip seperti mendeklarasikan signature sebuah method tanpa isi (body).

Bentuk umum:

[modifier] delegate [return type] [nama delegate] ([daftar parameter]);

Contoh:

public delegate void Logger(string message);

Deklarasi ini bisa diletakkan pada level namespace, di dalam class, atau di dalam struct, tergantung seberapa luas cakupan penggunaan Delegate tersebut dibutuhkan. Delegate yang dideklarasikan di dalam class hanya bisa diakses melalui nama class tersebut apabila memiliki modifier akses yang sesuai, sama seperti anggota class pada umumnya.

Signature

Signature dari sebuah Delegate mencakup dua hal: tipe dari setiap parameter (beserta urutannya) dan tipe dari return value. Sebuah method hanya bisa ditugaskan ke suatu Delegate apabila signature method tersebut identik dengan signature Delegate-nya.

public delegate int Operation(int a, int b);

public class Calculator
{
    public static int Add(int a, int b) => a + b;
    public static double Add(double a, double b) => a + b;
}

Operation op1 = Calculator.Add; // cocok, karena versi (int, int) mengembalikan int

Perlu dicatat bahwa nama parameter tidak diperhitungkan dalam pencocokan signature, hanya tipe dan urutannya. Nama parameter pada Delegate hanya berfungsi sebagai dokumentasi.

Return Value

Delegate bisa memiliki return type apa pun, termasuk void jika tidak mengembalikan nilai. Sebuah method hanya bisa ditugaskan ke Delegate apabila return type-nya sama persis (bukan sekadar compatible melalui implicit conversion, kecuali untuk kasus covariance yang akan dibahas pada Bagian 19).

public delegate string Formatter(int value);

public class Program
{
    public static string FormatCurrency(int value) => $"Rp{value:N0}";

    public static void Main()
    {
        Formatter formatter = FormatCurrency;
        Console.WriteLine(formatter(150000));
    }
}

Parameter

Delegate mendukung seluruh jenis parameter yang didukung oleh method biasa di C#, termasuk parameter opsional, params, ref, out, dan in.

Contoh dengan parameter out:

public delegate bool TryParseHandler(string input, out int result);

public class Program
{
    public static bool TryParseNumber(string input, out int result)
    {
        return int.TryParse(input, out result);
    }

    public static void Main()
    {
        TryParseHandler parser = TryParseNumber;
        if (parser("123", out int number))
        {
            Console.WriteLine($"Parsed: {number}");
        }
    }
}

Contoh dengan params:

public delegate int SumHandler(params int[] numbers);

public class Program
{
    public static int Sum(params int[] numbers)
    {
        int total = 0;
        foreach (var n in numbers) total += n;
        return total;
    }

    public static void Main()
    {
        SumHandler sum = Sum;
        Console.WriteLine(sum(1, 2, 3, 4));
    }
}

Delegate Type

Setiap deklarasi Delegate sebenarnya membentuk sebuah tipe baru, bukan sekadar alias dari method. Ini berarti dua Delegate yang memiliki signature identik namun nama tipe berbeda tetap dianggap sebagai dua tipe yang berbeda, sehingga tidak bisa saling ditukar secara langsung tanpa konversi eksplisit.

public delegate int Calculate(int a, int b);
public delegate int MathOperation(int a, int b);

Calculate calc = (a, b) => a + b;

// Baris di bawah ini tidak valid meskipun signature-nya sama:
// MathOperation math = calc;

// Harus dikonversi secara eksplisit:
MathOperation math = new MathOperation(calc);

Bagian 4: Cara Kerja Delegate

Delegate Menyimpan Referensi Method

Inti dari sebuah Delegate adalah kemampuannya menyimpan referensi ke method, bukan menyalin isi (body) method tersebut. Ini berarti ketika sebuah method ditugaskan ke Delegate, yang disimpan hanyalah "alamat" atau pointer menuju method itu di memori, beserta informasi objek target apabila method tersebut adalah instance method.

Karena yang disimpan adalah referensi, perubahan pada objek target akan tetap tercermin saat Delegate dipanggil, karena Delegate tidak pernah menyimpan salinan state, melainkan hanya menyimpan ke mana ia harus mengarah saat di-invoke.

public class Counter
{
    public int Value { get; private set; }

    public void Increment() => Value++;
}

public delegate void Action0();

public class Program
{
    public static void Main()
    {
        var counter = new Counter();
        Action0 increment = counter.Increment;

        increment();
        increment();
        increment();

        Console.WriteLine(counter.Value); // 3
    }
}

Pada contoh di atas, increment tidak menyimpan nilai Value itu sendiri, melainkan hanya menyimpan referensi ke method Increment pada instance counter. Setiap kali increment() dipanggil, ia benar-benar memanggil counter.Increment(), sehingga perubahan pada counter.Value selalu ter-update dengan benar.

Strongly Typed

Delegate di C# bersifat strongly typed, artinya compiler akan memvalidasi kecocokan tipe antara Delegate dan method yang ditugaskan kepadanya pada saat compile time, bukan pada saat runtime. Sifat ini yang membedakan Delegate dari function pointer mentah pada bahasa seperti C, yang rawan menimbulkan bug fatal apabila signature-nya tidak benar-benar cocok saat program dijalankan.

public delegate int Validator(string input);

public class Program
{
    public static bool IsValid(string input) => !string.IsNullOrEmpty(input);

    public static void Main()
    {
        // Baris di bawah tidak akan pernah lolos compile,
        // karena return type IsValid (bool) tidak cocok dengan Validator (int).
        // Validator validator = IsValid;
    }
}

Karena validasi ini terjadi di compile time, kesalahan semacam ini akan langsung terdeteksi sebelum kode sempat dijalankan, jauh berbeda dengan pendekatan function pointer konvensional yang baru bisa diketahui gagal setelah program berjalan dan menemui error runtime.

Signature Matching

Proses signature matching adalah proses yang dilakukan compiler untuk memastikan bahwa jumlah parameter, tipe parameter (beserta modifier seperti ref, out, atau in), urutan parameter, dan tipe return value dari method yang ditugaskan benar-benar identik dengan signature Delegate.

Signature matching juga berlaku untuk method generic, di mana compiler akan mencocokkan tipe hasil substitusi generic terhadap signature Delegate, bukan definisi generic method itu sendiri.

public delegate bool Comparer(int a, int b);

public class Program
{
    public static bool IsGreater(int a, int b) => a > b;
    public static bool IsGreaterOrEqual(int x, int y) => x >= y; // nama parameter berbeda, tetap cocok

    public static void Main()
    {
        Comparer comparer1 = IsGreater;         // cocok
        Comparer comparer2 = IsGreaterOrEqual;  // tetap cocok, karena nama parameter tidak diperhitungkan
    }
}

Runtime Invocation

Meskipun validasi tipe dilakukan pada compile time, pemanggilan aktual method yang direferensikan oleh Delegate baru benar-benar terjadi pada runtime, saat Invoke (atau pemanggilan langsung seperti delegateInstance()) dijalankan.

public delegate void Step();

public class Program
{
    public static void Main()
    {
        Step step = () => Console.WriteLine("Step 1");
        step += () => Console.WriteLine("Step 2");
        step += () => Console.WriteLine("Step 3");

        step(); // runtime invocation akan menjalankan ketiga method secara berurutan
    }
}

Proses runtime invocation secara umum melalui langkah berikut:

1. CLR membaca invocation list dari instance Delegate.
2. Untuk setiap entri dalam invocation list, CLR mengambil pasangan target object dan method pointer.
3. CLR memanggil method tersebut pada target object yang bersangkutan (atau langsung, jika method-nya static).
4. Jika Delegate memiliki return value dan berisi lebih dari satu method (multicast), hanya nilai kembalian dari method terakhir dalam invocation list yang akan dikembalikan sebagai hasil pemanggilan Delegate secara keseluruhan (dibahas lebih lanjut pada Bagian 6 mengenai Multicast Delegate).

Visualisasi Internal Object Delegate

Secara konsep, sebuah instance Delegate dapat dibayangkan sebagai objek yang menyimpan struktur berikut:

Delegate Instance
├── Target Object   -> referensi ke instance objek (null jika static method)
├── Method Pointer  -> alamat method yang akan dijalankan
└── Invocation List -> daftar (Target Object, Method Pointer) untuk kasus multicast
        ├── Entry 1: (Target A, Method A)
        ├── Entry 2: (Target B, Method B)
        └── Entry 3: (Target C, Method C)

Saat Delegate hanya menampung satu method (singlecast), invocation list secara internal tetap ada namun hanya berisi satu entri. Saat method digabungkan menggunakan +=, CLR akan membentuk instance Delegate baru dengan invocation list yang sudah diperluas, karena Delegate bersifat immutable: operasi += dan -= sebenarnya tidak mengubah instance Delegate yang sudah ada, melainkan membuat instance baru yang berisi invocation list hasil gabungan atau pengurangan.

Step step1 = () => Console.WriteLine("A");
Step step2 = step1;

step1 += () => Console.WriteLine("B");

// step2 tidak berubah, karena step1 += ... membuat instance baru,
// bukan memodifikasi instance yang sudah ada.

Pemahaman bahwa Delegate bersifat immutable ini penting terutama saat membahas Multicast Delegate pada Bagian 6, karena kesalahpahaman terhadap sifat ini sering menjadi sumber bug, misalnya saat seorang developer mengira menambahkan method ke satu variabel Delegate akan otomatis memengaruhi variabel lain yang sebelumnya menyimpan referensi yang sama.

Bagian 5: Singlecast Delegate

Definisi

Singlecast Delegate adalah istilah yang digunakan untuk menggambarkan sebuah instance Delegate yang hanya menyimpan satu method dalam invocation list-nya. Perlu ditekankan bahwa di C# sebenarnya tidak ada tipe khusus bernama "Singlecast Delegate" secara terpisah dari "Multicast Delegate": semua Delegate di C# secara internal adalah turunan dari System.MulticastDelegate, hanya saja ketika invocation list-nya berisi satu entri saja, secara konseptual ia disebut sebagai Singlecast Delegate.

Istilah ini berguna untuk membedakan skenario penggunaan: kapan sebuah Delegate dimaksudkan untuk menampung tepat satu method (misalnya untuk merepresentasikan satu strategi atau satu handler), dan kapan ia dimaksudkan untuk menampung banyak method sekaligus (dibahas pada Bagian 6).

Cara Membuat

Membuat Singlecast Delegate dilakukan dengan cara yang sama seperti deklarasi Delegate pada umumnya, hanya saja hanya satu method saja yang ditugaskan kepadanya, tanpa menggunakan operator +=.

public delegate decimal CalculatePrice(decimal basePrice);

public class Program
{
    public static decimal ApplyTax(decimal basePrice) => basePrice * 1.11m;

    public static void Main()
    {
        CalculatePrice calculatePrice = ApplyTax;
        Console.WriteLine(calculatePrice(100000));
    }
}

Assign Method

Penugasan method ke Delegate bisa dilakukan dengan beberapa cara: melalui named method (static maupun instance), anonymous method, atau lambda expression, selama signature-nya cocok dengan tipe Delegate yang dituju.

public delegate bool Validator(string input);

public class Program
{
    public static void Main()
    {
        // Menggunakan named method
        Validator validator1 = IsNotEmpty;

        // Menggunakan lambda expression
        Validator validator2 = input => !string.IsNullOrWhiteSpace(input);

        // Menggunakan anonymous method
        Validator validator3 = delegate (string input)
        {
            return input.Length > 3;
        };
    }

    public static bool IsNotEmpty(string input) => !string.IsNullOrEmpty(input);
}

Penugasan ulang ke variabel Delegate yang sama akan menggantikan method sebelumnya sepenuhnya, bukan menambahkannya, karena penugasan menggunakan = berbeda dengan penggabungan menggunakan +=.

Validator validator = input => input.Length > 0;
validator = input => input.Length > 5; // method sebelumnya sepenuhnya digantikan

Invoke

Sebuah Singlecast Delegate dapat dipanggil dengan dua cara: memanggilnya langsung layaknya sebuah method, atau memanggil method Invoke secara eksplisit. Kedua cara ini secara fungsional identik; pemanggilan langsung sebenarnya hanya syntactic sugar yang oleh compiler diterjemahkan menjadi pemanggilan Invoke.

Validator validator = input => input.Length >= 8;

bool result1 = validator("password123");     // pemanggilan langsung
bool result2 = validator.Invoke("password123"); // pemanggilan eksplisit melalui Invoke

C# versi terbaru juga mendukung null-conditional invocation menggunakan ?.Invoke(), yang berguna untuk menghindari NullReferenceException apabila Delegate yang dipanggil kemungkinan bernilai null, situasi yang umum terjadi terutama saat bekerja dengan Event.

Validator? validator = null;
bool? result = validator?.Invoke("test"); // aman, hasilnya null karena validator adalah null

Bagian 6: Multicast Delegate

Menggabungkan Delegate

Multicast Delegate adalah kondisi di mana sebuah instance Delegate menyimpan lebih dari satu method dalam invocation list-nya, sehingga satu kali pemanggilan Delegate akan menjalankan seluruh method yang tergabung di dalamnya secara berurutan. Kemampuan ini menjadikan Delegate sangat berguna untuk skenario di mana beberapa aksi perlu dijalankan sebagai respons terhadap satu kejadian yang sama, tanpa perlu memanggil masing-masing method secara manual satu per satu.

public delegate void NotificationHandler(string message);

public class Program
{
    public static void SendEmail(string message) => Console.WriteLine($"[Email] {message}");
    public static void SendSms(string message) => Console.WriteLine($"[SMS] {message}");

    public static void Main()
    {
        NotificationHandler notify = SendEmail;
        notify += SendSms;

        notify("Order confirmed."); // menjalankan SendEmail lalu SendSms
    }
}

Penggabungan method ke dalam sebuah Delegate dilakukan melalui method static Delegate.Combine, namun dalam praktiknya operator += jauh lebih umum digunakan karena lebih ringkas.

Operator +=

Operator += menambahkan method baru ke invocation list Delegate yang sudah ada. Karena Delegate bersifat immutable (sudah dibahas pada Bagian 4), operator ini sebenarnya membuat instance Delegate baru yang berisi gabungan invocation list lama ditambah method yang baru, kemudian menugaskan instance baru tersebut ke variabel yang bersangkutan.

NotificationHandler notify = SendEmail;
notify += SendSms;
notify += message => Console.WriteLine($"[Push] {message}");

Method yang sama juga bisa ditambahkan lebih dari sekali ke invocation list yang sama, dan ia akan dipanggil sebanyak jumlah ia ditambahkan.

NotificationHandler notify = SendEmail;
notify += SendEmail; // SendEmail sekarang ada dua kali dalam invocation list

notify("Test"); // SendEmail akan dipanggil dua kali

Operator -=

Operator -= menghapus method tertentu dari invocation list. Penghapusan dilakukan dengan mencari kecocokan persis antara target object dan method pointer; apabila ditemukan lebih dari satu kecocokan, hanya kemunculan terakhir dalam invocation list yang akan dihapus.

NotificationHandler notify = SendEmail;
notify += SendSms;
notify += SendEmail;

notify -= SendEmail; // hanya menghapus satu kemunculan SendEmail (yang terakhir)

notify("Test"); // SendEmail (pertama) dan SendSms tetap terpanggil

Perlu diperhatikan bahwa lambda expression atau anonymous method yang dibuat secara terpisah, meskipun terlihat identik secara logika, dianggap sebagai method yang berbeda oleh CLR sehingga tidak bisa dihapus menggunakan -= kecuali referensi Delegate-nya benar-benar sama persis (disimpan dalam variabel yang sama sebelumnya).

NotificationHandler notify = message => Console.WriteLine(message);
notify -= (message => Console.WriteLine(message)); // TIDAK menghapus apa pun, karena instance lambda berbeda

Invocation List

Invocation list adalah struktur internal yang menyimpan seluruh method yang tergabung dalam sebuah Multicast Delegate. Kita bisa mengakses invocation list ini secara terprogram melalui method GetInvocationList(), yang berguna misalnya untuk memeriksa berapa banyak method yang tergabung, atau untuk memanggil setiap method secara manual satu per satu (misalnya untuk menangani exception per method, dibahas di bagian berikutnya).

NotificationHandler notify = SendEmail;
notify += SendSms;

Delegate[] handlers = notify.GetInvocationList();
Console.WriteLine($"Jumlah handler: {handlers.Length}"); // 2

foreach (var handler in handlers)
{
    Console.WriteLine(handler.Method.Name);
}

Urutan Eksekusi

Method dalam invocation list dijalankan secara berurutan (sekuensial), sesuai urutan method tersebut ditambahkan, bukan secara paralel. Ini berarti method kedua baru akan mulai dijalankan setelah method pertama selesai sepenuhnya.

NotificationHandler notify = message => Console.WriteLine($"Step 1: {message}");
notify += message => Console.WriteLine($"Step 2: {message}");
notify += message => Console.WriteLine($"Step 3: {message}");

notify("Processing"); // Step 1, lalu Step 2, lalu Step 3, selalu dalam urutan ini

Karena eksekusinya bersifat sinkron dan berurutan, apabila salah satu method di tengah invocation list membutuhkan waktu lama untuk selesai (misalnya melakukan operasi I/O yang blocking), seluruh method setelahnya akan ikut tertunda.

Exception Handling

Salah satu hal penting yang perlu dipahami pada Multicast Delegate adalah perilakunya ketika salah satu method dalam invocation list melempar exception: seluruh proses pemanggilan akan langsung terhenti pada method yang melempar exception tersebut, dan method-method berikutnya dalam invocation list tidak akan dipanggil sama sekali.

NotificationHandler notify = message => Console.WriteLine("Handler 1: " + message);
notify += message => throw new InvalidOperationException("Handler 2 gagal");
notify += message => Console.WriteLine("Handler 3: " + message); // TIDAK akan pernah dipanggil

try
{
    notify("Test");
}
catch (InvalidOperationException ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}

Untuk menghindari perilaku "berhenti di tengah jalan" ini, pola yang umum digunakan adalah memanggil setiap method dalam invocation list secara manual menggunakan GetInvocationList(), sehingga exception pada satu handler tidak menghentikan handler lainnya.

NotificationHandler notify = message => Console.WriteLine("Handler 1: " + message);
notify += message => throw new InvalidOperationException("Handler 2 gagal");
notify += message => Console.WriteLine("Handler 3: " + message);

foreach (NotificationHandler handler in notify.GetInvocationList())
{
    try
    {
        handler("Test");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Salah satu handler gagal: {ex.Message}");
    }
}

// Handler 1 dan Handler 3 tetap terpanggil, meskipun Handler 2 melempar exception

Bagian 7: Delegate sebagai Parameter

Higher Order Function

Higher Order Function adalah istilah untuk method yang menerima method lain sebagai parameter, mengembalikan method sebagai hasilnya, atau bahkan melakukan keduanya. Delegate adalah mekanisme yang memungkinkan konsep Higher Order Function ini diterapkan di C#, karena tanpa Delegate, parameter suatu method hanya bisa berupa data biasa, bukan "perilaku" yang bisa dieksekusi.

Dengan menerima Delegate sebagai parameter, sebuah method bisa membiarkan pemanggilnya (caller) menentukan sendiri bagaimana suatu bagian dari logika dijalankan, tanpa method tersebut perlu tahu detail implementasinya.

public delegate int Operation(int a, int b);

public class Program
{
    public static int Calculate(int a, int b, Operation operation)
    {
        return operation(a, b);
    }

    public static void Main()
    {
        int sum = Calculate(5, 3, (a, b) => a + b);
        int product = Calculate(5, 3, (a, b) => a * b);

        Console.WriteLine(sum);     // 8
        Console.WriteLine(product); // 15
    }
}

Pada contoh di atas, method Calculate tidak perlu tahu apakah operasi yang dijalankan adalah penjumlahan, perkalian, atau operasi lain; ia hanya bertugas menjalankan Delegate yang diberikan kepadanya. Inilah esensi dari Higher Order Function: memisahkan apa yang dilakukan (dijalankan oleh method) dari bagaimana melakukannya (ditentukan oleh Delegate yang dikirim).

Callback Pattern

Callback Pattern adalah pola di mana sebuah method menerima Delegate sebagai parameter dengan tujuan agar Delegate tersebut dipanggil pada titik tertentu selama proses berjalan, biasanya setelah suatu tahapan selesai atau ketika suatu kejadian terjadi. Pola ini sangat umum digunakan untuk memberi tahu pemanggil tentang progres atau hasil dari sebuah proses, tanpa method yang menjalankan proses tersebut perlu mengetahui apa yang akan dilakukan setelah pemberitahuan itu.

public delegate void ProgressCallback(int percentage);

public class FileDownloader
{
    public void Download(string url, ProgressCallback onProgress)
    {
        for (int progress = 0; progress <= 100; progress += 25)
        {
            // simulasi proses download
            onProgress(progress);
        }
    }
}

public class Program
{
    public static void Main()
    {
        var downloader = new FileDownloader();
        downloader.Download("https://example.com/file.zip", percentage =>
        {
            Console.WriteLine($"Progress: {percentage}%");
        });
    }
}

Callback juga umum digunakan untuk membedakan penanganan hasil sukses dan gagal, dengan menerima dua Delegate sekaligus sebagai parameter.

public delegate void OnSuccess(string data);
public delegate void OnError(string errorMessage);

public class ApiClient
{
    public void FetchData(bool simulateError, OnSuccess onSuccess, OnError onError)
    {
        if (simulateError)
        {
            onError("Gagal mengambil data dari server.");
        }
        else
        {
            onSuccess("{ \"status\": \"ok\" }");
        }
    }
}

public class Program
{
    public static void Main()
    {
        var client = new ApiClient();
        client.FetchData(
            simulateError: false,
            onSuccess: data => Console.WriteLine($"Sukses: {data}"),
            onError: error => Console.WriteLine($"Error: {error}")
        );
    }
}

Dependency Injection Sederhana

Delegate juga bisa dimanfaatkan sebagai bentuk sederhana dari Dependency Injection, terutama untuk kasus di mana yang perlu "disuntikkan" hanyalah satu perilaku spesifik, bukan seluruh implementasi dari sebuah interface. Pendekatan ini sering disebut juga sebagai functional dependency injection, karena dependency yang disuntikkan berupa fungsi, bukan objek dengan banyak method.

public class PriceCalculator
{
    private readonly Func<decimal, decimal> _taxStrategy;

    public PriceCalculator(Func<decimal, decimal> taxStrategy)
    {
        _taxStrategy = taxStrategy;
    }

    public decimal CalculateFinalPrice(decimal basePrice)
    {
        return basePrice + _taxStrategy(basePrice);
    }
}

public class Program
{
    public static void Main()
    {
        var domesticCalculator = new PriceCalculator(price => price * 0.11m); // PPN 11%
        var internationalCalculator = new PriceCalculator(price => price * 0.05m); // pajak internasional 5%

        Console.WriteLine(domesticCalculator.CalculateFinalPrice(100000));
        Console.WriteLine(internationalCalculator.CalculateFinalPrice(100000));
    }
}

Dibandingkan dengan Dependency Injection konvensional menggunakan interface, pendekatan berbasis Delegate ini lebih ringkas untuk kasus sederhana, namun kurang cocok apabila dependency yang disuntikkan memiliki banyak method terkait yang perlu dikelola sebagai satu kesatuan; untuk kasus semacam itu, interface tetap menjadi pilihan yang lebih tepat (dibahas lebih lanjut pada Bagian 29 mengenai perbandingan Delegate vs Interface).

Contoh: Sorting

public class Program
{
    public static void Main()
    {
        var numbers = new List<int> { 5, 2, 8, 1, 9 };

        numbers.Sort((a, b) => a.CompareTo(b)); // ascending
        Console.WriteLine(string.Join(", ", numbers));

        numbers.Sort((a, b) => b.CompareTo(a)); // descending
        Console.WriteLine(string.Join(", ", numbers));
    }
}

Contoh: Payment Strategy

public delegate bool PaymentStrategy(decimal amount);

public class PaymentProcessor
{
    public void Process(decimal amount, PaymentStrategy strategy)
    {
        bool success = strategy(amount);
        Console.WriteLine(success ? "Pembayaran berhasil." : "Pembayaran gagal.");
    }
}

public class Program
{
    public static bool PayWithCreditCard(decimal amount)
    {
        Console.WriteLine($"Memproses kartu kredit sebesar {amount}");
        return true;
    }

    public static bool PayWithEWallet(decimal amount)
    {
        Console.WriteLine($"Memproses e-wallet sebesar {amount}");
        return amount <= 5000000;
    }

    public static void Main()
    {
        var processor = new PaymentProcessor();
        processor.Process(2500000, PayWithCreditCard);
        processor.Process(6000000, PayWithEWallet);
    }
}

Contoh: Validation

public delegate bool ValidationRule(string input);

public class Program
{
    public static bool Validate(string input, params ValidationRule[] rules)
    {
        foreach (var rule in rules)
        {
            if (!rule(input))
            {
                return false;
            }
        }
        return true;
    }

    public static void Main()
    {
        bool isValid = Validate(
            "budi123",
            input => !string.IsNullOrWhiteSpace(input),
            input => input.Length >= 6,
            input => input.Any(char.IsDigit)
        );

        Console.WriteLine(isValid); // true
    }
}

Bagian 8: Anonymous Method

Anonymous Method

Anonymous Method adalah cara untuk mendefinisikan blok kode yang ditugaskan langsung ke sebuah Delegate tanpa perlu membuat method terpisah dengan nama tertentu. Fitur ini diperkenalkan pada C# 2.0 sebagai jawaban atas kebutuhan menulis logika sederhana secara langsung di tempat Delegate tersebut digunakan, tanpa harus mendeklarasikan method baru hanya untuk dipakai satu kali.

Sebelum Anonymous Method hadir, setiap kali sebuah Delegate membutuhkan implementasi kecil dan spesifik, developer harus membuat method terpisah, meskipun method tersebut hanya akan dipakai pada satu tempat saja. Anonymous Method menghilangkan kebutuhan ini dengan mengizinkan blok kode ditulis langsung sebagai bagian dari ekspresi penugasan Delegate.

Kata Kunci delegate

Anonymous Method dituliskan menggunakan kata kunci delegate, diikuti dengan daftar parameter (opsional) dan blok kode di dalam kurung kurawal, tanpa nama method.

public delegate int Calculate(int a, int b);

public class Program
{
    public static void Main()
    {
        Calculate add = delegate (int a, int b)
        {
            return a + b;
        };

        Console.WriteLine(add(5, 3)); // 8
    }
}

Anonymous Method juga bisa dituliskan tanpa parameter sama sekali, bahkan tanpa tanda kurung, apabila Delegate yang dituju tidak memiliki parameter.

public delegate void Notify();

public class Program
{
    public static void Main()
    {
        Notify notify = delegate
        {
            Console.WriteLine("Notifikasi terkirim.");
        };

        notify();
    }
}

Salah satu karakteristik unik dari Anonymous Method adalah kemampuannya untuk mengabaikan daftar parameter sepenuhnya menggunakan kata kunci delegate tanpa tanda kurung, bahkan ketika Delegate targetnya memiliki parameter. Dalam kasus ini, parameter tersebut diabaikan begitu saja di dalam body method.

public delegate void LogHandler(string message, int severity);

public class Program
{
    public static void Main()
    {
        LogHandler logger = delegate
        {
            Console.WriteLine("Log diterima, parameter diabaikan.");
        };

        logger("Error terjadi", 3);
    }
}

Kelebihan

Beberapa kelebihan Anonymous Method dibandingkan dengan named method konvensional:

• Tidak perlu mendeklarasikan method terpisah untuk logika yang hanya dipakai satu kali, sehingga kode menjadi lebih ringkas dan lebih mudah dibaca dalam konteks penggunaannya.
• Bisa mengakses (meng-capture) variabel dari lingkup (scope) di luar Anonymous Method itu sendiri, sebuah kemampuan yang disebut closure, yang akan dibahas lebih dalam pada Bagian 9.
• Mengurangi jarak antara deklarasi logika dan tempat logika tersebut digunakan, sehingga lebih mudah dipahami dibandingkan harus mencari method terpisah di bagian lain dari kode.

public class Program
{
    public static void Main()
    {
        int threshold = 10;

        Func<int, bool> isAboveThreshold = delegate (int value)
        {
            return value > threshold; // meng-capture variabel 'threshold' dari luar
        };

        Console.WriteLine(isAboveThreshold(15)); // true
    }
}

Kekurangan

Meskipun bermanfaat, Anonymous Method juga memiliki beberapa kekurangan yang membuatnya kini jarang dipakai, terutama setelah kehadiran Lambda Expression:

• Sintaksnya masih tergolong verbose dibandingkan Lambda Expression, terutama untuk logika yang sangat sederhana.
• Tidak bisa digunakan sebagai expression tree, yang dibutuhkan misalnya oleh LINQ to SQL atau Entity Framework untuk menerjemahkan logika C# menjadi query database; hanya Lambda Expression berbentuk expression lambda yang bisa dikonversi menjadi expression tree.
• Anonymous Method yang kompleks dan panjang cenderung membuat kode sulit dibaca, terutama apabila ditulis langsung sebagai argumen dari sebuah method call, sehingga mengaburkan alur logika utama.
• Sulit untuk melakukan debugging pada Anonymous Method yang bertumpuk (nested) di dalam Anonymous Method lain, karena stack trace yang dihasilkan cenderung kurang deskriptif dibandingkan named method.

Perbandingan: Method, Anonymous Method, dan Lambda

Ketiga pendekatan berikut secara fungsional setara, namun berbeda dari sisi keringkasan sintaks dan kapan masing-masing lebih tepat digunakan.

Named Method, paling tepat digunakan apabila logika tersebut cukup kompleks, dipakai berulang kali di banyak tempat, atau perlu diuji secara terpisah (unit testing).

public delegate bool IsEven(int number);

public static bool CheckEven(int number) => number % 2 == 0;

IsEven checkEven = CheckEven;

Anonymous Method, cocok untuk kasus transisi ketika perlu meng-capture variabel luar namun tetap membutuhkan blok kode dengan beberapa baris statement, meskipun saat ini jarang dipilih karena Lambda Expression mampu melakukan hal yang sama dengan sintaks lebih ringkas.

IsEven checkEven = delegate (int number)
{
    return number % 2 == 0;
};

Lambda Expression, menjadi pilihan paling umum saat ini karena paling ringkas, mendukung expression tree, dan tetap mendukung closure seperti Anonymous Method.

IsEven checkEven = number => number % 2 == 0;

Ringkasnya, Lambda Expression pada dasarnya adalah evolusi dari Anonymous Method dengan sintaks yang jauh lebih ringkas dan dukungan tambahan seperti expression tree, sehingga di kode C# modern, Anonymous Method dengan kata kunci delegate sudah sangat jarang ditemui kecuali pada kode lama (legacy) yang belum dimodernisasi.

Bagian 9: Lambda Expression

Operator =>

Lambda Expression menggunakan operator => (dibaca "goes to" atau "menghasilkan") untuk memisahkan daftar parameter di sisi kiri dengan isi (body) ekspresi atau statement di sisi kanan. Diperkenalkan pada C# 3.0, Lambda Expression menjadi cara paling ringkas dan paling umum digunakan untuk membuat instance Delegate di C# modern.

public delegate int Square(int number);

public class Program
{
    public static void Main()
    {
        Square square = number => number * number;
        Console.WriteLine(square(5)); // 25
    }
}

Apabila parameter lebih dari satu, daftar parameter dituliskan di dalam tanda kurung; apabila hanya satu parameter, tanda kurung bersifat opsional (meskipun tetap boleh dituliskan untuk kejelasan).

public delegate int Add(int a, int b);

Add add = (a, b) => a + b;

Tipe data parameter juga bisa dituliskan secara eksplisit apabila diperlukan, meskipun umumnya compiler bisa menyimpulkannya sendiri (type inference) dari tipe Delegate yang dituju.

Add add = (int a, int b) => a + b;

Expression Lambda

Expression Lambda adalah bentuk lambda yang isinya hanya berupa satu ekspresi tunggal, tanpa kurung kurawal maupun kata kunci return. Hasil dari ekspresi tersebut secara implisit menjadi nilai yang dikembalikan.

public delegate bool IsPositive(int number);

IsPositive isPositive = number => number > 0;

Expression Lambda inilah yang bisa dikonversi menjadi expression tree, yaitu representasi data dari struktur sebuah ekspresi, yang banyak dimanfaatkan oleh library seperti Entity Framework untuk menerjemahkan logika C# menjadi query SQL.

using System.Linq.Expressions;

Expression<Func<int, bool>> expression = number => number > 0;
Console.WriteLine(expression.Body); // menampilkan struktur ekspresi, bukan hasil eksekusi

Statement Lambda

Statement Lambda adalah bentuk lambda yang isinya berupa satu atau lebih statement, dituliskan di dalam kurung kurawal, dan menggunakan kata kunci return secara eksplisit apabila Delegate-nya memiliki return value.

public delegate int Categorize(int score);

Categorize categorize = score =>
{
    if (score >= 90) return 1;
    if (score >= 70) return 2;
    return 3;
};

Console.WriteLine(categorize(85)); // 2

Statement Lambda tidak bisa dikonversi menjadi expression tree, karena expression tree hanya mendukung representasi dari satu ekspresi tunggal, bukan rangkaian statement dengan alur kontrol seperti percabangan atau perulangan.

Capture Variable

Sama seperti Anonymous Method, Lambda Expression juga bisa mengakses (meng-capture) variabel dari lingkup di luar dirinya. Variabel yang di-capture akan tetap "hidup" dan bisa diakses oleh lambda tersebut meskipun method tempat variabel itu dideklarasikan sudah selesai dieksekusi.

public class Program
{
    public static Func<int> CreateCounter()
    {
        int count = 0;
        return () =>
        {
            count++;
            return count;
        };
    }

    public static void Main()
    {
        var counter = CreateCounter();
        Console.WriteLine(counter()); // 1
        Console.WriteLine(counter()); // 2
        Console.WriteLine(counter()); // 3
    }
}

Pada contoh di atas, variabel count seharusnya sudah tidak ada lagi begitu method CreateCounter selesai dieksekusi, sesuai dengan aturan lifetime variabel lokal pada umumnya. Namun karena lambda yang dikembalikan meng-capture count, CLR akan memperpanjang lifetime variabel tersebut selama lambda itu masih direferensikan, dengan cara memindahkannya ke dalam objek closure yang dialokasikan di heap.

Closure

Closure adalah istilah untuk kombinasi antara sebuah fungsi (dalam hal ini, lambda) dengan lingkungan (environment) tempat variabel-variabel yang di-capture tersebut disimpan. Closure memungkinkan lambda "mengingat" nilai variabel dari lingkup luar, bahkan setelah lingkup tersebut secara normal seharusnya sudah berakhir.

Penting untuk dipahami bahwa closure meng-capture variabel, bukan nilai pada saat lambda dibuat. Ini berarti apabila variabel yang di-capture berubah setelah lambda dibuat namun sebelum lambda tersebut dipanggil, lambda akan melihat nilai yang paling terbaru, bukan nilai pada saat lambda pertama kali dideklarasikan.

public class Program
{
    public static void Main()
    {
        var actions = new List<Action>();

        for (int i = 0; i < 3; i++)
        {
            int captured = i; // disalin ke variabel baru agar setiap lambda meng-capture nilai berbeda
            actions.Add(() => Console.WriteLine(captured));
        }

        foreach (var action in actions)
        {
            action(); // mencetak 0, 1, 2
        }
    }
}

Sejak C# 5.0, variabel iterasi pada foreach (namun bukan for konvensional) sudah secara otomatis memiliki scope baru pada setiap iterasi, sehingga closure pada foreach tidak lagi memerlukan variabel perantara seperti contoh for di atas. Namun pada for klasik seperti contoh di atas, praktik menyalin ke variabel baru per iterasi tetap relevan untuk dipahami, terutama saat membaca kode lama atau saat bekerja dengan pola perulangan manual lainnya.

Best Practice

Beberapa praktik terbaik dalam penggunaan Lambda Expression:

• Gunakan Expression Lambda untuk logika sederhana satu baris, dan Statement Lambda hanya ketika benar-benar dibutuhkan lebih dari satu statement, agar kode tetap ringkas dan mudah dibaca.
• Hindari lambda yang terlalu panjang dan kompleks, jika logika sudah melebihi beberapa baris atau memiliki banyak percabangan, pertimbangkan untuk mengekstraknya menjadi named method agar lebih mudah diuji dan dibaca.
• Berhati-hati saat meng-capture variabel dalam loop, terutama untuk memastikan setiap lambda meng-capture nilai yang dimaksud, bukan variabel yang nilainya berubah seiring iterasi berikutnya.
• Perhatikan biaya alokasi memori: setiap lambda yang meng-capture variabel dari luar akan membuat objek closure baru di heap setiap kali lambda tersebut dibuat, yang bisa berdampak pada performa apabila dilakukan berulang kali dalam hot path (dibahas lebih lanjut pada Bagian 32 mengenai Performance).
• Gunakan lambda static (static (a, b) => a + b, didukung sejak C# 9) apabila lambda tersebut tidak perlu meng-capture variabel apa pun dari luar, untuk mencegah capture yang tidak disengaja sekaligus menghindari alokasi closure yang tidak perlu.

Add add = static (a, b) => a + b; // compiler akan menolak jika lambda ini mencoba meng-capture variabel luar

Bagian 10: Generic Delegate

Generic Delegate

Generic Delegate adalah Delegate yang dideklarasikan dengan satu atau lebih type parameter, sehingga tipe data yang digunakan pada parameter maupun return value-nya tidak ditentukan secara kaku saat deklarasi, melainkan ditentukan kemudian saat Delegate tersebut digunakan. Kemampuan ini diperkenalkan bersamaan dengan generic type pada C# 2.0, dan menjadi dasar bagi tipe Delegate bawaan seperti Action<T>, Func<T, TResult>, dan Predicate<T> yang akan dibahas pada Bagian 11 hingga 13.

// Tanpa generic, perlu Delegate terpisah untuk setiap tipe:
public delegate int ProcessInt(int value);
public delegate string ProcessString(string value);
public delegate double ProcessDouble(double value);

Tanpa Generic Delegate, setiap kali dibutuhkan Delegate dengan tipe data yang berbeda, developer harus mendeklarasikan Delegate baru untuk masing-masing kombinasi tipe, yang jelas tidak efisien dan sulit dikelola.

Dengan Generic Delegate, satu deklarasi saja sudah cukup untuk menangani berbagai tipe data:

public delegate T Process<T>(T value);

Type Parameter

Type parameter pada Generic Delegate dituliskan di antara tanda < dan > setelah nama Delegate, dan bisa digunakan sebagai tipe untuk parameter maupun return value dari Delegate tersebut.

public delegate TResult Transformer<TInput, TResult>(TInput input);

public class Program
{
    public static void Main()
    {
        Transformer<int, string> intToString = value => $"Nilai: {value}";
        Transformer<string, int> stringLength = value => value.Length;

        Console.WriteLine(intToString(100));    // Nilai: 100
        Console.WriteLine(stringLength("Halo")); // 4
    }
}

Type parameter juga bisa dibatasi menggunakan generic constraint, misalnya untuk memastikan tipe yang digunakan mengimplementasikan interface tertentu atau memiliki constructor tanpa parameter.

public delegate bool Comparer<T>(T a, T b) where T : IComparable<T>;

public class Program
{
    public static void Main()
    {
        Comparer<int> isGreater = (a, b) => a.CompareTo(b) > 0;
        Console.WriteLine(isGreater(10, 5)); // true
    }
}

Reuse

Keuntungan utama Generic Delegate adalah kemampuannya untuk digunakan ulang (reuse) di berbagai konteks dengan tipe data yang berbeda-beda, tanpa perlu mendeklarasikan Delegate baru setiap kali kebutuhan tipe data berubah. Satu deklarasi Generic Delegate bisa dipakai untuk tipe primitif seperti int dan string, maupun untuk tipe kompleks seperti class atau record buatan sendiri.

public delegate bool Validator<T>(T item);

public class Employee
{
    public string Name { get; set; } = string.Empty;
    public decimal Salary { get; set; }
}

public class Program
{
    public static bool IsPositive(int number) => number > 0;
    public static bool HasValidSalary(Employee employee) => employee.Salary > 0;

    public static void Main()
    {
        Validator<int> numberValidator = IsPositive;
        Validator<Employee> employeeValidator = HasValidSalary;

        Console.WriteLine(numberValidator(5));
        Console.WriteLine(employeeValidator(new Employee { Name = "Budi", Salary = 3000000 }));
    }
}

Contoh Generic Processor

Sebagai contoh yang lebih lengkap, berikut sebuah "Generic Processor" yang memanfaatkan Generic Delegate untuk memproses sebuah nilai melalui rangkaian langkah (pipeline) yang bisa berbeda-beda tergantung tipe data dan kebutuhan pemanggilnya.

public delegate TOutput Processor<TInput, TOutput>(TInput input);

public class DataPipeline<TInput, TOutput>
{
    private readonly Processor<TInput, TOutput> _process;

    public DataPipeline(Processor<TInput, TOutput> process)
    {
        _process = process;
    }

    public TOutput Run(TInput input) => _process(input);
}

public class Program
{
    public static void Main()
    {
        var upperCasePipeline = new DataPipeline<string, string>(input => input.ToUpper());
        Console.WriteLine(upperCasePipeline.Run("halo dunia")); // HALO DUNIA

        var squarePipeline = new DataPipeline<int, int>(input => input * input);
        Console.WriteLine(squarePipeline.Run(6)); // 36

        var summaryPipeline = new DataPipeline<List<int>, string>(
            numbers => $"Total: {numbers.Sum()}, Rata-rata: {numbers.Average():F2}"
        );
        Console.WriteLine(summaryPipeline.Run(new List<int> { 10, 20, 30 })); // Total: 60, Rata-rata: 20.00
    }
}

Contoh DataPipeline<TInput, TOutput> di atas menunjukkan bagaimana Generic Delegate memungkinkan satu class yang sama digunakan untuk berbagai kombinasi tipe input dan output, tanpa perlu menulis ulang logika pipeline untuk setiap jenis data yang berbeda. Pendekatan semacam ini menjadi fondasi penting yang nantinya akan terlihat jelas manfaatnya saat membahas Func, Action, dan Predicate pada bagian-bagian selanjutnya, yang pada dasarnya adalah kumpulan Generic Delegate siap pakai yang sudah disediakan oleh .NET.

Bagian 11: Action

Action

Action adalah salah satu Generic Delegate bawaan yang disediakan oleh .NET dalam namespace System, digunakan untuk merepresentasikan sebuah method yang tidak mengembalikan nilai (return type-nya selalu void). Kehadiran Action dan keluarganya menghilangkan kebutuhan untuk mendeklarasikan Delegate custom secara manual pada kebanyakan kasus umum, karena Action sudah mencakup berbagai kombinasi jumlah parameter yang mungkin dibutuhkan.

public class Program
{
    public static void Main()
    {
        Action greet = () => Console.WriteLine("Halo!");
        greet();
    }
}

Versi paling sederhana, Action tanpa type parameter, digunakan untuk method tanpa parameter sama sekali.

Action<T>

Action<T> digunakan untuk method yang menerima satu parameter bertipe T dan tidak mengembalikan nilai.

public class Program
{
    public static void Main()
    {
        Action<string> print = message => Console.WriteLine(message);
        print("Data berhasil disimpan.");
    }
}

Action<T1, T2>

Action<T1, T2> menerima dua parameter dengan tipe yang bisa berbeda satu sama lain.

public class Program
{
    public static void Main()
    {
        Action<string, int> logWithLevel = (message, level) =>
        {
            Console.WriteLine($"[Level {level}] {message}");
        };

        logWithLevel("Koneksi database terputus", 3);
    }
}

Hingga Action<T1...T16>

.NET menyediakan varian Action dari tanpa parameter hingga maksimal 16 parameter (Action<T1, T2, ..., T16>), sehingga hampir seluruh kebutuhan jumlah parameter dalam praktik sehari-hari sudah tercakup tanpa perlu mendeklarasikan Delegate custom.

public class Program
{
    public static void Main()
    {
        Action<string, string, decimal, int, DateTime> recordTransaction =
            (accountNumber, transactionType, amount, referenceId, timestamp) =>
        {
            Console.WriteLine(
                $"Rekening {accountNumber} - {transactionType} sebesar {amount} " +
                $"(Ref: {referenceId}) pada {timestamp:yyyy-MM-dd HH:mm}"
            );
        };

        recordTransaction("1234567890", "TRANSFER", 500000, 90001, DateTime.Now);
    }
}

Meskipun Action mendukung hingga 16 parameter, dalam praktiknya method dengan jumlah parameter sebanyak itu jarang ditemui dan justru menjadi indikasi bahwa desain method tersebut perlu dipertimbangkan ulang, misalnya dengan mengelompokkan parameter-parameter terkait ke dalam sebuah class atau record tersendiri.

Contoh: Logger

public class Program
{
    public static void Main()
    {
        Action<string> logInfo = message => Console.WriteLine($"[INFO] {message}");
        Action<string> logError = message => Console.WriteLine($"[ERROR] {message}");

        logInfo("Aplikasi dimulai.");
        logError("Gagal terhubung ke database.");
    }
}

Contoh: Notification

public class NotificationService
{
    public void Notify(string recipient, Action<string> sendMethod)
    {
        sendMethod(recipient);
    }
}

public class Program
{
    public static void Main()
    {
        var service = new NotificationService();

        service.Notify("budi@example.com", recipient =>
            Console.WriteLine($"Mengirim email ke {recipient}"));

        service.Notify("08123456789", recipient =>
            Console.WriteLine($"Mengirim SMS ke {recipient}"));
    }
}

Contoh: Repository

public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
}

public class EmployeeRepository
{
    private readonly List<Employee> _employees = new();

    public void Add(Employee employee, Action<Employee> onAdded)
    {
        _employees.Add(employee);
        onAdded(employee);
    }
}

public class Program
{
    public static void Main()
    {
        var repository = new EmployeeRepository();

        repository.Add(
            new Employee { Id = 1, Name = "Budi" },
            employee => Console.WriteLine($"Employee {employee.Name} berhasil ditambahkan dengan Id {employee.Id}")
        );
    }
}