C# Generic Delegate

​

Custom Generic Delegate Declaration

// T1 and T2 are type parameters for the input parameters; TResult is the type parameter for the return type.
public delegate TResult CustomMapper<T1, T2, TResult>(T1 arg1, T2 arg2);

​

Instantiation, Assignment, and Invocation

// Assignment via lambda expression
CustomMapper<int, int, string> mapper = (x, y) => (x + y).ToString();

// Assignment via method group
Func<int, string> intToString = Convert.ToString;

// Invocation
string result1 = mapper(5, 10);   // Evaluates to "15"
string result2 = intToString(42); // Evaluates to "42"

​

Built-in Generic Delegates

1. Action<T> Encapsulates a method that takes up to 16 input parameters and returns void. The delegate itself accepts up to 16 generic type parameters corresponding to the types of those input parameters.
   public delegate void Action<in T>(T obj);
   public delegate void Action<in T1, in T2>(T1 arg1, T2 arg2);
   
2. Func<T, TResult> Encapsulates a method that takes up to 16 input parameters and returns a value. The delegate supports up to 17 generic type parameters total: up to 16 for the input parameters, plus 1 for the return type (TResult). The return type is always the final type parameter in the signature.
   public delegate TResult Func<out TResult>();
   public delegate TResult Func<in T, out TResult>(T arg);
   
3. Predicate<T> Encapsulates a method that defines a set of criteria and determines whether the specified object meets those criteria. It accepts exactly one generic type parameter for its single input parameter and always returns a bool.
   public delegate bool Predicate<in T>(T obj);
   

​

Variance in Generic Delegates

• Covariance (out): Applied to return types. It permits a delegate to return a more derived type than the one specified by the generic type parameter.
• Contravariance (in): Applied to input parameters. It permits a delegate to accept parameters of a less derived (more generic) type than the one specified by the generic type parameter.

// Covariant delegate (can return a derived type)
public delegate T CovariantDelegate<out T>();

// Contravariant delegate (can accept a base type)
public delegate void ContravariantDelegate<in T>(T item);

​

Type Constraints

// T must be a reference type and have a parameterless constructor
public delegate void ConstrainedDelegate<T>(T item) where T : class, new();