Delegates and Events - potatoscript/csharp GitHub Wiki

🥔 Delegates and Events in C# 🥔

🎯 What Are Delegates in C#?

A delegate in C# is like a remote control that tells a TV what to do. 🎮📺 You press a button, and the TV knows whether to change the channel, adjust the volume, or turn off.

In C# terms:

A delegate is a pointer to a method.
It allows you to call a method without knowing its exact name.
Delegates can hold references to one or more methods and call them dynamically.

🥔 Why Use Delegates?

Imagine you’re running a potato warehouse. Sometimes you want to:

📦 Pack the potatoes.
🚚 Ship the potatoes.
🧹 Clean the warehouse.

Instead of calling each method separately, you can assign them to a delegate and call them dynamically when needed.

🧠 How to Declare a Delegate

🥔 Step 1: Declare a Delegate

You declare a delegate like you declare a function prototype.

public delegate void PotatoAction(string message);

✅ Explanation:

public delegate – Declares a delegate.
void – Return type of the method it points to.
PotatoAction – Name of the delegate.
string message – Parameter that the delegate’s method will accept.

🥔 Step 2: Create Methods That Match the Delegate Signature

public class PotatoWarehouse
{
    public void PackPotatoes(string message)
    {
        Console.WriteLine("📦 Packing Potatoes: " + message);
    }

    public void ShipPotatoes(string message)
    {
        Console.WriteLine("🚚 Shipping Potatoes: " + message);
    }
}

✅ Explanation:

PackPotatoes() and ShipPotatoes() are two methods that match the delegate’s signature.
Both accept a string parameter and return void.

🥔 Step 3: Assign Methods to a Delegate

class Program
{
    static void Main()
    {
        PotatoWarehouse warehouse = new PotatoWarehouse();
        
        // Create a delegate instance
        PotatoAction action;

        // Assign PackPotatoes to the delegate
        action = warehouse.PackPotatoes;
        action("Golden Potatoes");

        // Change delegate to ShipPotatoes
        action = warehouse.ShipPotatoes;
        action("Purple Potatoes");
    }
}

✅ Explanation:

action = warehouse.PackPotatoes – Assigns the PackPotatoes method to the delegate.
action("Golden Potatoes") – Calls the PackPotatoes() method.
action = warehouse.ShipPotatoes – Reassigns the delegate to ShipPotatoes.

🎁 Output:

📦 Packing Potatoes: Golden Potatoes
🚚 Shipping Potatoes: Purple Potatoes

🎉 Multicast Delegates

A multicast delegate is like pressing multiple buttons on the remote control 🎮. You can assign multiple methods to a single delegate, and they all get called!

🥔 Example: Multicast Delegate

class Program
{
    static void Main()
    {
        PotatoWarehouse warehouse = new PotatoWarehouse();
        
        // Create a delegate instance
        PotatoAction action;

        // Add multiple methods to the delegate
        action = warehouse.PackPotatoes;
        action += warehouse.ShipPotatoes;

        // Call all methods in the delegate
        action("Golden Potatoes");
    }
}

✅ Explanation:

action += warehouse.ShipPotatoes – Adds another method to the delegate.
When action is called, both PackPotatoes and ShipPotatoes are executed.

🎁 Output:

📦 Packing Potatoes: Golden Potatoes
🚚 Shipping Potatoes: Golden Potatoes

🔥 Anonymous Methods and Lambda Expressions

If you don’t want to create a separate method, you can use anonymous methods or lambda expressions.

🥔 Anonymous Method Example:

PotatoAction action = delegate(string message)
{
    Console.WriteLine("🍠 Anonymous Method says: " + message);
};

action("Hello from anonymous method!");

✅ Explanation:

delegate(string message) – Anonymous method without a name.
Can be assigned directly to the delegate.

🥔 Lambda Expression Example:

PotatoAction action = (message) => Console.WriteLine("🔥 Lambda says: " + message);
action("Hello from lambda!");

✅ Explanation:

(message) => ... – Shorter syntax for anonymous methods.
Simplifies writing methods directly inside a delegate.

🎁 Output:

🍠 Anonymous Method says: Hello from anonymous method!
🔥 Lambda says: Hello from lambda!

🎯 What Are Events in C#?

An event in C# is like a potato alarm that tells you when something important happens. ⏰🥔

Events are special delegates that notify subscribers when something happens.
Publisher – The class that raises the event.
Subscriber – The class that listens and reacts to the event.

🧠 How to Declare and Use Events

🥔 Step 1: Define a Delegate for the Event

public delegate void PotatoProcessedEventHandler(string message);

🥔 Step 2: Define the Event in a Class

public class PotatoProcessor
{
    // Declare an event
    public event PotatoProcessedEventHandler PotatoProcessed;

    public void ProcessPotatoes(string type)
    {
        Console.WriteLine($"🔪 Processing {type} Potatoes...");

        // Raise the event after processing
        if (PotatoProcessed != null)
        {
            PotatoProcessed.Invoke($"{type} Potatoes are ready! 🥔🎉");
        }
    }
}

✅ Explanation:

PotatoProcessed – Event that will notify when the potatoes are processed.
ProcessPotatoes() – Method that processes the potatoes and raises the event.

🥔 Step 3: Create a Subscriber to Handle the Event

public class WarehouseManager
{
    public void OnPotatoProcessed(string message)
    {
        Console.WriteLine("📣 Notification: " + message);
    }
}

✅ Explanation:

OnPotatoProcessed() – Method that reacts when the event is raised.

🥔 Step 4: Subscribe to the Event

class Program
{
    static void Main()
    {
        PotatoProcessor processor = new PotatoProcessor();
        WarehouseManager manager = new WarehouseManager();

        // Subscribe to the event
        processor.PotatoProcessed += manager.OnPotatoProcessed;

        // Process the potatoes and raise the event
        processor.ProcessPotatoes("Golden");
    }
}

✅ Explanation:

processor.PotatoProcessed += manager.OnPotatoProcessed – Subscribes the method to the event.
ProcessPotatoes("Golden") – Raises the event and notifies all subscribers.

🎁 Output:

🔪 Processing Golden Potatoes...
📣 Notification: Golden Potatoes are ready! 🥔🎉

🥔 Multicast Events (Multiple Subscribers)

You can have multiple subscribers to the same event. It’s like multiple warehouse managers listening for potato updates. 🏢🔔

🥔 Example:

class Program
{
    static void Main()
    {
        PotatoProcessor processor = new PotatoProcessor();
        WarehouseManager manager1 = new WarehouseManager();
        WarehouseManager manager2 = new WarehouseManager();

        // Subscribe both managers
        processor.PotatoProcessed += manager1.OnPotatoProcessed;
        processor.PotatoProcessed += manager2.OnPotatoProcessed;

        // Process potatoes and notify both managers
        processor.ProcessPotatoes("Purple");
    }
}

🎁 Output:

🔪 Processing Purple Potatoes...
📣 Notification: Purple Potatoes are ready! 🥔🎉
📣 Notification: Purple Potatoes are ready! 🥔🎉

🎯 Summary of Delegates and Events in C#

🌟 Concept	📝 Description
🎮 Delegates	A pointer to a method in C#
📺 Multicast Delegates	Call multiple methods at once
⚡ Events	Notify subscribers when something happens
🧠 Lambda Expressions	Short-hand syntax for anonymous methods
🔔 Subscriber	Listens and reacts to events
🏢 Publisher	Raises the event to notify subscribers