ডেলিগেটস, ইভেন্টস এবং ল্যামবডাস (Delegates, Events & Lambdas)

// Define a delegate type (the "shape" of methods it can hold)
delegate int MathOperation(int a, int b);

// Methods that match the delegate's shape
static int Add(int a, int b) => a + b;
static int Multiply(int a, int b) => a * b;
static int Max(int a, int b) => a > b ? a : b;

// Use the delegate like a variable
MathOperation op = Add;
Console.WriteLine($"Add: {op(10, 5)}");

op = Multiply;  // point at a different method
Console.WriteLine($"Multiply: {op(10, 5)}");

op = Max;
Console.WriteLine($"Max: {op(10, 5)}");

// Pass a delegate to another method
static int ApplyToArray(int[] numbers, MathOperation operation)
{
    int result = numbers[0];
    for (int i = 1; i < numbers.Length; i++)
        result = operation(result, numbers[i]);
    return result;
}

int[] nums = { 3, 7, 2, 9, 4 };
Console.WriteLine($"\nSum of all: {ApplyToArray(nums, Add)}");
Console.WriteLine($"Product: {ApplyToArray(nums, Multiply)}");
Console.WriteLine($"Largest: {ApplyToArray(nums, Max)}");

Add: 15
Multiply: 50
Max: 10

Sum of all: 25
Product: 1512
Largest: 9

// Action — takes input, returns nothing
Action<string> shout = message => Console.WriteLine(message.ToUpper() + "!!!");
shout("hello");
shout("watch out");

// Func — takes input, returns output
Func<int, int, int> add = (a, b) => a + b;
Func<string, int> wordCount = text => text.Split(' ').Length;
Func<double, double> toCelsius = f => (f - 32) * 5.0 / 9.0;

Console.WriteLine($"3 + 4 = {add(3, 4)}");
Console.WriteLine($"Words: {wordCount("The quick brown fox")}");
Console.WriteLine($"72°F = {toCelsius(72):F1}°C");

// Lambda with multiple statements (use { })
Func<int, string> classify = n =>
{
    if (n > 0) return "positive";
    if (n < 0) return "negative";
    return "zero";
};

Console.WriteLine($"5 is {classify(5)}");
Console.WriteLine($"-3 is {classify(-3)}");
Console.WriteLine($"0 is {classify(0)}");

// Passing lambdas directly (no variable needed)
var numbers = new List<int> { 5, 12, 8, 3, 17, 9 };
var big = numbers.Where(n => n > 10).ToList();
Console.WriteLine($"\nBigger than 10: [{string.Join(", ", big)}]");

HELLO!!!
WATCH OUT!!!
3 + 4 = 7
Words: 4
72°F = 22.2°C
5 is positive
-3 is negative
0 is zero

Bigger than 10: [12, 17]

class TemperatureSensor
{
    // Event that fires when temperature changes
    public event Action<double>? TemperatureChanged;
    public event Action<double>? OverheatWarning;

    private double _temp;

    public void SetTemperature(double newTemp)
    {
        _temp = newTemp;
        Console.WriteLine($"Sensor: Temperature is now {_temp}°C");

        // Fire the event — notify all subscribers
        TemperatureChanged?.Invoke(_temp);

        if (_temp > 100)
            OverheatWarning?.Invoke(_temp);
    }
}

// Create sensor
var sensor = new TemperatureSensor();

// Subscribe to events with lambdas
sensor.TemperatureChanged += temp =>
    Console.WriteLine($"  Logger: Recorded {temp}°C");

sensor.TemperatureChanged += temp =>
    Console.WriteLine($"  Display: Showing {temp}°C on screen");

sensor.OverheatWarning += temp =>
    Console.WriteLine($"  ALARM: DANGER! {temp}°C is too hot!");

// Simulate temperature changes
sensor.SetTemperature(22.5);
Console.WriteLine();
sensor.SetTemperature(75.0);
Console.WriteLine();
sensor.SetTemperature(105.3);

Sensor: Temperature is now 22.5°C
  Logger: Recorded 22.5°C
  Display: Showing 22.5°C on screen

Sensor: Temperature is now 75°C
  Logger: Recorded 75°C
  Display: Showing 75°C on screen

Sensor: Temperature is now 105.3°C
  Logger: Recorded 105.3°C
  Display: Showing 105.3°C on screen
  ALARM: DANGER! 105.3°C is too hot!

// Higher-order method: takes a function as a parameter
static List<T> Filter<T>(List<T> items, Func<T, bool> predicate)
{
    var result = new List<T>();
    foreach (var item in items)
        if (predicate(item))
            result.Add(item);
    return result;
}

static List<TOut> Map<TIn, TOut>(List<TIn> items, Func<TIn, TOut> transform)
{
    var result = new List<TOut>();
    foreach (var item in items)
        result.Add(transform(item));
    return result;
}

// Use with different lambdas — same method, different behavior!
var names = new List<string> { "Anika", "Rafi", "Sadia", "Tariq", "Esha" };

var longNames = Filter(names, n => n.Length > 3);
var shouted = Map(names, n => n.ToUpper());
var lengths = Map(names, n => n.Length);

Console.WriteLine($"Long names: [{string.Join(", ", longNames)}]");
Console.WriteLine($"Shouted:    [{string.Join(", ", shouted)}]");
Console.WriteLine($"Lengths:    [{string.Join(", ", lengths)}]");

// Callback pattern: "call me when you're done"
static void DownloadData(string url, Action<string> onComplete)
{
    // Simulate download
    string data = $"Data from {url}";
    Console.WriteLine($"Downloading {url}...");
    onComplete(data);  // call the callback!
}

DownloadData("api.example.com/users", result =>
{
    Console.WriteLine($"Got: {result}");
});

Long names: [Anika, Sadia, Tariq]
Shouted:    [ALICE, BOB, CHARLIE, DIANA, EVE]
Lengths:    [5, 3, 7, 5, 3]
Downloading api.example.com/users...
Got: Data from api.example.com/users