Delegates & Events in C#

1. Why Do We Need Delegates?

You want to pass behavior as a parameter. Kunal wants to tell the delivery guy what to do when pizza arrives: call, ring bell, or leave at door. Instead of hardcoding, pass the action.

// Declare: what kind of action?
public delegate void PizzaArrivedAction(string address);

// Use: Kunal passes his choice
PizzaArrivedAction action = KunalCallMe;
action("123 Main St"); // Calls KunalCallMe

2. Multicast: One Call, Many Actions

Delegates can chain methods with +=. When pizza arrives, call Kunal AND Prerna AND notify security.

action += PrernaMessageMe;
action += SecurityLog;
// One invoke → all 3 run in order

3. Events: Delegates With Guardrails

event keyword means only the publisher can invoke. Kaushal owns the pizza tracker. Others can only subscribe += or unsubscribe -=. They can't fire it or reset it.

public class PizzaTracker {
    public event PizzaArrivedAction OnArrived; // Safe
    public void DeliverPizza() { OnArrived?.Invoke("123 Main St"); } // Only I can call
}

1. Why Do We Need Delegates & Events?

Hardcoding callbacks kills flexibility. LINQ, button clicks, async operations all need "call me back later" patterns. Delegates give you type-safe function variables. Events enforce publisher-subscriber pattern so random code can't fake your button click.

2. Delegate Basics: Type-Safe Function Pointers

A delegate defines a method signature. Any method matching that signature can be assigned.

public delegate int MathOp(int x, int y);

MathOp add = (a, b) => a + b;
MathOp multiply = KunalMultiply;

int result = add(5, 3); // 8

Why not Func/Action? Func<int,int,int> works, but named delegates communicate intent. OrderProcessor delegate is clearer than Func<Order,bool>.

3. Multicast & Invocation Order

All delegates are multicast. += chains them. They execute in subscription order. Return value = last method only.

MathOp ops = add;
ops += multiply; // First add, then multiply
int final = ops(5,3); // 15, because multiply ran last. Add result lost.

4. Events: The event Keyword Difference

5. Memory: How Delegates Work Under The Hood

A delegate is a class with Target, Method, and InvocationList fields. For instance methods, Target holds the object reference. That's why subscribing to an event keeps the subscriber object alive. GC can't collect Kashvee if the long-lived PizzaTracker event still points to her method.