Events, Delegates, and Methods in .NET — Same Family, Different Roles

When learning C#, many developers wonder:
👉 “Delegates, events, methods… they all look connected. Are they the same thing?”

The answer: they are related (like siblings in the same family), but each has a unique responsibility in the bigger picture of how .NET applications communicate.

Let’s break it down step by step.

https://dotnetfullstackdev.medium.com/

---

🧑‍🤝‍🧑 The Family Picture

Think of methods, delegates, and events like three family members working together in a play:

• Method → The performer (actual action you want to execute).

• Delegate → The contract (says: “Any performer who matches this signature is welcome”).

• Event → The manager (decides when performers should be called and who can subscribe).

---

📌 1. Methods — The Actual Workhorses

A method is the actual block of code that performs a task.

Example:

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

This method does the job. It doesn’t know when or why it should run — it just knows how to send an email.

👉 In family terms: Methods are the “doers.”

---

📌 2. Delegates — The Contracts Between Code

A delegate is like a “type-safe function pointer.” It defines the shape of methods it can point to.

Example:

public delegate void NotificationHandler(string message);

• This delegate says: “I can point to any method that takes a string and returns void.”

• It doesn’t implement the method — it just defines the signature contract.

Using it:

NotificationHandler handler = SendEmail; // Point delegate to method
handler("Order placed successfully");    // Calls SendEmail method

👉 Delegates are the connectors that allow us to pass methods around like variables.

3. Events — The Organized Coordinators

Now, an event is built on top of a delegate.
It’s like saying: “We’ll use this delegate, but only in a controlled, publish-subscribe way.”

Example:

public class OrderProcessor {
    public event NotificationHandler? OrderPlaced;

    public void PlaceOrder(string order) {
        Console.WriteLine($"Order '{order}' placed.");
        OnOrderPlaced($"Order '{order}' placed at {DateTime.Now}");
    }

    protected virtual void OnOrderPlaced(string message) {
        OrderPlaced?.Invoke(message);
    }
}

Usage:

var processor = new OrderProcessor();

// Subscribers
processor.OrderPlaced += SendEmail;
processor.OrderPlaced += msg => Console.WriteLine($"📲 SMS sent: {msg}");

processor.PlaceOrder("Laptop");

Output:

Order 'Laptop' placed.
📧 Email sent: Order 'Laptop' placed at 09-06-2025
📲 SMS sent: Order 'Laptop' placed at 09-06-2025

👉 Events make sure:

• Only the publisher can raise (invoke) them.

• Subscribers can register/unregister safely.

• Communication is loosely coupled (publisher doesn’t care who listens).

How They Work Together

1. Method: You write the logic (send email, update DB, log to file).

2. Delegate: Defines the shape of methods allowed.

3. Event: Exposes that delegate in a safe way so external subscribers can hook in.

In code:

// Step 1: Delegate
public delegate void OrderNotification(string message);

// Step 2: Event
public class Store {
    public event OrderNotification? OrderPlaced;

    public void PlaceOrder(string product) {
        Console.WriteLine($"Order placed: {product}");
        OrderPlaced?.Invoke($"Order for {product} placed at {DateTime.Now}");
    }
}

// Step 3: Methods (subscribers)
public void SendEmail(string msg) => Console.WriteLine($"📧 {msg}");
public void SendSMS(string msg)   => Console.WriteLine($"📲 {msg}");

Usage:

var store = new Store();

// Hook methods to event
store.OrderPlaced += SendEmail;
store.OrderPlaced += SendSMS;

// Trigger
store.PlaceOrder("Smartphone");

Why This Separation Matters

• Flexibility → You can plug in or remove subscribers anytime.

• Loose Coupling → Publisher never hard-codes “send email” or “send SMS.”

• Reusability → The same event can trigger multiple different methods.

• Testability → You can hook fake subscribers in unit tests.

---

Quick Analogy

• Method = “Cooking pasta.”

• Delegate = “Recipe format: takes ingredients, returns a dish.”

• Event = “Dinner bell: whoever is hungry can come eat when pasta is ready.”

Same family, different jobs.

---

Takeaway

• Methods = What gets done (logic).

• Delegates = How it should look (signature contract).

• Events = When and who gets notified (publish/subscribe).

Together, they form the foundation of event-driven programming in .NET.