C# delegates.

C# Delegates are a type-safe function pointers that reference methods or functions with a particular signature. They enable you to treat methods as first-class objects, which means you can pass them as arguments to other methods, store them in data structures, and invoke them just like regular functions.

In C#, delegates are defined using the delegate keyword, followed by the return type, the delegate name, and the method signature in parentheses. For example:

delegate int MyDelegate(int x, int y);

This declares a delegate named MyDelegate that can reference methods that take two int parameters and return an int.

To use a delegate, you first create an instance of it and associate it with a method that matches its signature. This is known as “binding” the delegate to the method. For example:

int Add(int x, int y) { return x + y; }
MyDelegate del = new MyDelegate(Add);

This creates an instance of MyDelegate named del and binds it to the Add method. Now you can invoke the delegate just like a regular function:

int result = del(2, 3); // result = 5

Delegates can also be used to implement event handling. In this scenario, a delegate is associated with an event and is used to call methods that have been registered to handle that event.

Delegates are a powerful tool for creating flexible and extensible code in C#. They allow you to separate concerns by passing methods as arguments and can simplify complex code by encapsulating functionality in a single delegate instance.

Example 1

Here’s an example that demonstrates how to use delegates in C#:

using System;

// Define a delegate type
delegate int MyDelegate(int x, int y);

class Program
{
    // A method that matches the delegate signature
    static int Add(int x, int y)
    {
        return x + y;
    }

    // Another method that matches the delegate signature
    static int Subtract(int x, int y)
    {
        return x - y;
    }

    static void Main(string[] args)
    {
        // Create delegate instances and bind them to methods
        MyDelegate addDelegate = new MyDelegate(Add);
        MyDelegate subDelegate = new MyDelegate(Subtract);

        // Invoke the delegates
        int result1 = addDelegate(2, 3);
        int result2 = subDelegate(5, 2);

        Console.WriteLine("Result of adding 2 and 3: {0}", result1);
        Console.WriteLine("Result of subtracting 2 from 5: {0}", result2);
    }
}

This example defines a delegate type named MyDelegate that takes two int parameters and returns an int. It then defines two methods named Add and Subtract that match the delegate signature.

In the Main method, it creates two delegate instances, addDelegate and subDelegate, and binds them to the Add and Subtract methods, respectively. It then invokes each delegate and outputs the results to the console.

When you run this code, you should see the following output:

Result of adding 2 and 3: 5
Result of subtracting 2 from 5: 3

To pass a method to a class using a delegate in C#, you can define a delegate type that matches the signature of the method, and then pass an instance of the delegate to the class as a parameter. Here’s an example:

using System;

// Define a delegate type
delegate void MyDelegate(string message);

class MyClass
{
    // A field to store the delegate
    private MyDelegate _delegate;

    // A constructor that takes a delegate parameter
    public MyClass(MyDelegate del)
    {
        _delegate = del;
    }

    // A method that invokes the delegate
    public void DoSomething(string message)
    {
        if (_delegate != null)
        {
            _delegate(message);
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Create an instance of MyClass and pass a method as a delegate
        MyClass obj = new MyClass(PrintMessage);

        // Call the DoSomething method, which will invoke the delegate
        obj.DoSomething("Hello, world!");
    }

    static void PrintMessage(string message)
    {
        Console.WriteLine(message);
    }
}

In this example, we define a class named MyClass that has a private field _delegate of type MyDelegate, a constructor that takes a delegate parameter and assigns it to the _delegate field, and a method DoSomething that invokes the delegate if it’s not null.

In the Main method, we create an instance of MyClass and pass the PrintMessage method as a delegate using its method name. When we call the DoSomething method on the instance, it will invoke the PrintMessage method through the delegate.

When you run this code, you should see the following output:

Hello, world!

Func Delegates

The Func in C# is a generic delegate type that represents a function that takes one or more input parameters and returns a value of a specified type. It’s similar to a regular delegate, but it’s more convenient to use because you don’t need to define a custom delegate type for each function signature you want to use.

The Func delegate type takes up to 16 input parameters, and the last type parameter specifies the return type of the function. For example, Func<int, string>; is a delegate type that represents a function that takes an int parameter and returns a string value.

Here’s an example of using Func to define and call a simple function that adds two numbers:

using System;

class Program
{
    static void Main(string[] args)
    {
        Func<int, int, int> add = (x, y) => x + y;

        int result = add(2, 3);

        Console.WriteLine("The result of adding 2 and 3 is: {0}", result);
    }
}

In this example, we define a Func<int, int, int> delegate named add that takes two int parameters and returns an int value. We then assign a lambda expression that adds the two input parameters to the add delegate.

We can then call the add delegate with the input parameters 2 and 3 to get a result of 5, which we output to the console.

Note that the Func delegate is often used in LINQ queries, as it allows you to pass functions as parameters to LINQ methods like Select and Where. It’s also commonly used in asynchronous programming with the Task and async/await keywords.

The main difference between a delegate and a Func delegate in C# is that a delegate can represent any method with a matching signature, while a Func delegate specifically represents a function that takes one or more input parameters and returns a value of a specified type.

In other words, a delegate can represent a method that doesn’t return a value, or a method that returns a value but doesn’t take any parameters, whereas a Func delegate specifically represents a method that returns a value and takes one or more input parameters.

Here’s an example that demonstrates the difference between a delegate and a Func delegate:

using System;

delegate void MyDelegate(int x, int y);

class Program
{
    static void Main(string[] args)
    {
        // Define a delegate and assign it to a method
        MyDelegate del = Add;

        // Invoke the delegate with input parameters
        del(2, 3);

        // Define a Func delegate and assign it to a method
        Func<int, int, int> addFunc = Add;

        // Invoke the Func delegate with input parameters
        int result = addFunc(2, 3);

        Console.WriteLine("Result of adding 2 and 3 using a delegate: N/A");
        Console.WriteLine("Result of adding 2 and 3 using a Func delegate: {0}", result);
    }

    static void Add(int x, int y)
    {
        Console.WriteLine(x + y);
    }

    static int Add(int x, int y)
    {
        return x + y;
    }
}

In this example, we define a delegate named MyDelegate that takes two int parameters and doesn’t return a value, and we assign it to the Add method that doesn’t return a value. We then invoke the delegate with input parameters 2 and 3, which outputs the result to the console.

We then define a Func<int, int, int> delegate named addFunc that takes two int parameters and returns an int value, and we assign it to the Add method that returns an int value. We then invoke the addFunc delegate with input parameters 2 and 3, which returns the result 5 as an int value.

Note that in this example, we have two methods with the same name Add but different return types, and we can assign each method to a different type of delegate (a MyDelegate delegate and a Func<int, int, int> delegate) based on their signature.

So how to define Func with void return?

The Func delegate in C# represents a function that returns a value of a specified type. If you want to define a delegate that doesn’t return a value (i.e., a void method), you should use the Action delegate instead.

The Action delegate is similar to Func, but it doesn’t have a return type. Instead, it’s used to represent a method that takes zero or more input parameters and doesn’t return a value. Here’s an example of using Action to define a delegate that takes two int parameters and doesn’t return a value:

using System;

class Program
{
    static void Main(string[] args)
    {
        Action<int, int> printSum = (x, y) => Console.WriteLine(x + y);

        printSum(2, 3);
    }
}

In this example, we define an Action<int, int> delegate named printSum that takes two int parameters and doesn’t return a value. We then assign a lambda expression that outputs the sum of the input parameters to the printSum delegate.

We can then call the printSum delegate with the input parameters 2 and 3 to output the result 5 to the console.

Note that the Action delegate is similar to Func in that it’s a generic delegate type that takes up to 16 input parameters. You can use Action to define a delegate that takes any number of input parameters and doesn’t return a value. For example, Action with no type parameters is equivalent to a delegate that takes no input parameters and doesn’t return a value (void method).

Delegates in other programming languages

Here are some examples of delegate-like features in other programming languages:

Python: In Python, functions are first-class objects, which means that they can be passed as arguments to other functions and returned as values from functions. Python also has a built-in map function, which takes a function and an iterable as arguments and applies the function to each element of the iterable, returning a new iterable of the results. Python also supports lambda functions, which are anonymous functions that can be used inline.
C++: C++ has function pointers, which are variables that can hold the memory address of a function. Function pointers can be passed as arguments to other functions, and they can also be used to create callbacks.
Ruby: In Ruby, blocks are a way to pass a chunk of code to a method. Blocks are similar to lambdas in Python and anonymous functions in other languages. Blocks can be passed as arguments to other methods, and they can also be used to create iterators.
Go: In Go, functions are first-class objects and can be passed as arguments to other functions and returned as values from functions. Go also has anonymous functions, which are similar to lambdas in other languages. Go also has interfaces, which can be used to define a set of methods that a type must implement. Interfaces can be used to create callback functions.
JavaScript/TypeScript: In JavaScript and TypeScript, functions are first-class objects and can be passed as arguments to other functions and returned as values from functions. JavaScript and TypeScript also have arrow functions, which are anonymous functions that can be used inline. JavaScript and TypeScript also have the concept of callbacks, which are functions that are passed as arguments to other functions and are called at a later time.
Rust: In Rust, closures are similar to anonymous functions in other languages. Closures can capture variables from their enclosing environment and can be passed as arguments to other functions. Rust also has traits, which are similar to interfaces in other languages. Traits can be used to define a set of methods that a type must implement, and they can be used to create callback functions. Rust also has function pointers, which are similar to function pointers in C++.

Here are some simple examples for each language:

Python:


# Example of using a lambda function
numbers = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x**2, numbers))
print(squares)

C++:

// Example of using a function pointer
#include <iostream>
using namespace std;

void printHello() {
    cout << "Hello!" << endl;
}

void callFunction(void (*function)()) {
    function();
}

int main() {
    callFunction(printHello);
    return 0;
}

Ruby:

# Example of using a block
numbers = [1, 2, 3, 4, 5]
squares = numbers.map { |x| x**2 }
puts squares

// Example of using a closure
package main

import "fmt"

func multiplyBy(n int) func(int) int {
    return func(x int) int {
        return x * n
    }
}

func main() {
    double := multiplyBy(2)
    triple := multiplyBy(3)

    fmt.Println(double(5)) // Output: 10
    fmt.Println(triple(5)) // Output: 15
}

JavaScript/TypeScript:

// Example of using a callback function
function printHello() {
    console.log("Hello!");
}

function callFunction(callback) {
    callback();
}

callFunction(printHello);

Rust

// Example of using a closure
fn main() {
    let double = |x: i32| x * 2;
    let triple = |x: i32| x * 3;

    println!("{}", double(5)); // Output: 10
    println!("{}", triple(5)); // Output: 15
}

Exercises

Create a delegate that takes two integers as parameters and returns an integer. Assign different methods to this delegate that perform arithmetic operations such as addition, subtraction, multiplication and division. Invoke the delegate with different arguments and print the results.
Create a delegate that takes a string as a parameter and returns a bool. Assign different methods to this delegate that check various conditions on the string such as length, case, palindrome etc. Invoke the delegate with different strings and print the results.
Create an event handler delegate that takes an object and an EventArgs as parameters and returns void. Create a custom event class that inherits from EventArgs and has some properties such as message, time etc. Create a publisher class that has an event of type event handler delegate and raises it when some condition is met. Create a subscriber class that has a method that handles the event by printing its properties. Subscribe to the event using += operator or += syntax.

More Exercises

Create a generic delegate that can take any type of parameters and return any type of value. Use this delegate to invoke different methods with different signatures such as string concatenation, square root calculation, array sorting etc.
Create a multicast delegate that can hold multiple methods with the same signature. Use this delegate to invoke all the methods at once and print their results. Add or remove methods from the delegate using += or -= operators.
Create an extension method for a delegate that can filter out null values from an array of delegates. Use this method to invoke only non-null delegates from an array that may contain some null values.