Action action = () => Console.WriteLine("Action done.");
// invoked as method call
action()

// user-declared delegate, no parameters
delegate void MyAction();
MyAction myAction = () => Console.WriteLine("My action done.");
myAction()

/// Method that writes "Done." to console output.
public void WriteDone() {
    Console.WriteLine("Done.");
}

Action actionDone = WriteDone;
actionDone()

Action actionWithParam = (int i) => Console.WriteLine(i);

// type of lambda parameter `i` is determined from declaration of delegate object
Action<int> actionOnInteger1 = i => Console.WriteLine(i);
// same as
// type of delegate object is determined from definition of lambda
var actionOnInteger2 = (int i) => Console.WriteLine(i);
actionOnInteger2(0)

actionOnInteger2.GetType()

// user-declared delegate, one parameter
delegate void MyActionOnInteger(int i);
MyActionOnInteger myActionOnInteger = i => Console.WriteLine(i);
myActionOnInteger(0)

Action<int> actionThatReturns = i => { return i * 2; };

// the last generic type is the return type. Parameters are optional
Func<string> func = () => "Function returned.";
var returned = func();
returned

// user-declared delegate that returns a string, same as previous Func
delegate string MyFunc();
MyFunc myFunc = () => "My function returned.";
returned = myFunc();
returned

Func<int, int, int> funcMultiply = (x, y) => x * y;
funcMultiply(2, 3)

delegate int MyFuncMultiply(int x, int y);
MyFuncMultiply myFuncMultiply = (x, y) => x * y;
myFuncMultiply(2, 3)

Action actions = () => Console.WriteLine("first method");
actions += action;
actions += actionDone;
actions += () => Console.WriteLine("last method");
actions()

actions.GetInvocationList().Count()

public void WriteAsUpper(string message) {
    Console.WriteLine(message.ToUpper());
}

public void WriteLength(string message) {
    Console.WriteLine(message.Length);
}

public string CreateMessage(string title, string text, DateTime date, Action<string> writeCallback) {
    var message = $"{title}\n{text}\n{date.ToLongDateString()}";

    // I already know the delegate type: it receives a string and doesn't return anything. Ok more than enough info
    // But what does it do? I COULD CARE LESS, just call it :)
    writeCallback(message);
    
    return message;
}

var redMessage = CreateMessage("Red", "Roses are red", DateTime.Now, WriteLength);

redMessage

var blueMessage = CreateMessage("Blue", "Blue roses are fake", DateTime.Now, WriteAsUpper);

/// Inheriting from List to skip specific implementations from interfaces, irrelevant for our topic,
/// so we can use foreach statements directly and focus on our custom methods and delegates.
class IntList : List<int> {
    /// Custom delegate equivalent to Func<int, bool>
    public delegate bool ConditionCallback(int integer);

    /// Equivalent for Where
    public IEnumerable<int> Filter(ConditionCallback condition) {
        foreach (var integer in this) {
            if (condition(integer)) {
                yield return integer;
            }
        }
    }

    /// Equivalent for Select<T>
    public IEnumerable<TReturn> Map<TReturn>(Func<int, TReturn> mapper) {
        foreach (var integer in this) {
            yield return mapper(integer);
        }
    }

    /// Equivalent for All
    public bool Every(ConditionCallback condition) {
        foreach (var integer in this) {
            if (!condition(integer)) {
                return false;
            }
        }

        return true;
    }

    /// Equivalent for Any
    public bool Some(ConditionCallback condition) {
        foreach (var integer in this) {
            if (condition(integer)) {
                return true;
            }
        }

        return false;
    }
}

var ints = new IntList { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

// get the fifth part of each integer as double
ints.Map(i => i / 5.0)

// get integers as string percentages
ints.Map(i => $"{i * 10}%")

bool IsEven(int integer) {
    return integer % 2 == 0;
}

bool IsOdd(int integer) {
    // reuse code!
    return !IsEven(integer);
}

ints.Filter(IsEven)

ints.Filter(IsOdd)

// are there some even integers?
ints.Some(IsEven)

var odds = new IntList { 3, 5, 7, 11, 13, 17 };
// is every integer odd?
odds.Every(IsOdd)