What is a C# delegate?

In C#, a delegate is a type that represents references to methods with a specific signature. Delegates allow you to treat methods as first-class citizens, meaning you can assign them to variables, pass them as arguments to other methods, and invoke them dynamically at runtime. Delegates play a crucial role in enabling event handling, callbacks, and encapsulating method references.

Key characteristics of C# delegates include:

1. Signature Matching: Delegates are defined with a specific signature that corresponds to the method(s) they can reference. The signature includes the return type and parameter list.

2. Type Safety: Delegates provide type safety because they ensure that the referenced method(s) have a compatible signature. This prevents runtime errors caused by mismatched method calls.

3. Multicast Delegates: C# supports multicast delegates, which can reference multiple methods. When invoked, all referenced methods are executed sequentially.

4. Event Handling: Delegates are commonly used in event handling scenarios, where an object can notify multiple listeners (subscribers) when an event occurs. Events in C# are based on delegates.

Here’s a simplified example of defining and using a delegate:

```csharp
// Define a delegate signature
public delegate void MyDelegate(int value);

// Create a method that matches the delegate's signature
public void PrintNumber(int num)
{
    Console.WriteLine($"Number: {num}");
}

// Create an instance of the delegate and associate it with the method
MyDelegate myDelegate = PrintNumber;

// Invoke the delegate, which calls the associated method
myDelegate(42); // Output: "Number: 42"

In this example, `MyDelegate` is a delegate type that can reference methods with a single integer parameter. We create an instance of the delegate and associate it with the `PrintNumber` method. When we invoke the delegate, it calls the `PrintNumber` method with the provided argument.

Delegates are powerful tools in C# for achieving decoupling, extensibility, and dynamic method invocation. They are widely used in scenarios like event handling, callbacks, and implementing various design patterns.