Empower Your C# Code with Dynamic Functionality: A tour to C# delegate

What is a delegate?

a delegate is a reference type variable that holds the reference of a method. C# delegates are similar to the C / C++ equivalent of pointers to the method - a delegate holds the address of a method that can be called using the delegate.

A delegate is an object that knows how to call a method.

Defining the delegate

A delegate type defines the kind of method that delegate instances can call. Specifically, it defines the method’s return type and its parameter types. The following defines a delegate type called Transformer:

delegate int Transformer (int x);

above delegate Transformer is compatible with any method with an int return type and a single int parameter. for example

    int Square (int x) { return x * x; }
    // OR
    int Square (int x) => x * x;

assigning a method to a delegate variable creates a delegate instance. a delegate instance can be invoked in the same way as a method.

Transformer t = Square;
int answer = t(3);  // 9
//OR 
int answer = t.Invoke(3); // 9

// t(3) is shorthand for t.Invoke(3)

💡

A delegate instance acts as a delegate for the caller: the caller invokes the delegate, and then the delegate calls the target method. This indirection decouples the caller from the target method

Delegates are used to define callback methods and implement event handling.
Delegates allow methods to be passed as parameters.
Delegates can be chained together; for example, multiple methods can be called on a single event (multicast delegates).

Multicast delegates

all delegates have multicast ability which means a delegate instance can reference more than one method.

SomeDelegate d = SomeMethod1;
d += SomeMethod2;

multicast delegates are invoked in the order in which they are added.
a method could be removed at runtime from the multicast delegate.

d -= SomeMethod1;
If a multicast delegate has a nonvoid return type, the caller receives the return value from the last method to be invoked. for most of the scenarios where multicast delegates are used, methods have a void return type.

Generic delegate types

A delegate type can have generic type parameters and return type :

public delegate T Transformer<T> (T arg);
int[] values = { 1, 2, 3 };
Util.Transform (values, Square); // Hook in Square
foreach (int i in values)
  Console.Write (i + " "); // 1 4 9
int Square (int x) => x * x;
public class Util {
 public static void Transform<T> (T[] values, Transformer<T> t) {
   for (int i = 0; i < values.Length; i++)
     values[i] = t (values[i]);
 }
}

The Func and Action Delegates

both Func and Action delegates are reference types that encapsulate a method.

The Func delegate refers to a method that accepts some parameters and returns a value.

The Action delegate refers to a method that accepts parameters but do not return any value.

below is the declaration syntax of a Func delegate :

Func<in_param 1, in_param 2, out_Param > name ;

      static void Main(string[] args) {
         Func<string, string, string> func = Concat;
         string fullName = func("Deepak", "Jain");
         Console.WriteLine(fullName);
         Console.ReadLine();
      }
      static string Concat (string firstName, string lastName) {
         return firstName + lastName;
      }

Below is an example of Action delegate :

Action<in_param> name

static void Main(string[] args) {
         Action<string> act = Display;
         act("Hello World"); // Hello World
         Console.ReadLine();
      }
      static Display (string content) {
         console.log(content);
      }

That's it for this article, please share your feedback in comment section.

references and further reading

C# 10 in a Nutshell: The Definitive Reference

C# delegates

Comments

C# beginner tutorial

C# : Boxing and Unboxing

More from this blog

ASP.NET Core Configuration Guide

How to Modernize Legacy Delphi Applications with a Hybrid Approach

Working with EF Core pipeline

Options pattern in ASP.NET Core: Advance scenario

Options pattern in ASP.NET Core: Introduction

What is a delegate?

Defining the delegate

Multicast delegates

Generic delegate types

The Func and Action Delegates

Command Palette

Comments

C# beginner tutorial

C# : Boxing and Unboxing

More from this blog

What is a delegate?

Defining the delegate

Multicast delegates

Generic delegate types

The Func and Action Delegates