Different Ways To Create Delegates In C#

Introduction

A Delegate is a reference type that means it encapsulates method(s). It decouples the class that declares the delegate from the class that uses it. Declaring class doesn't need to know what class will use the Delegate.

Delegates are very useful in some cases like passing method as parameter, callback, calling multiple methods in a single event, etc. But, this article is not intended to explain detailed concepts of Delegate. It will only explain the different ways to create a Delegate.

The following are the different ways to create or use Delegate:

Action
Func
Predicate
Lambda
Anonymous Types.

Basically, all these types of Delegate provide a way to create a generic delegate without explicitly declaring a custom delegate. I will explain in detail about all these kinds of Delegates.

I will explain and focus on only Action, Func and Predicate Delegates.

Action

An Action is a type of Delegate. Basically, it encapsulates a method that has a single parameter and does not return a value. It is required when developer doesn't want to declare Delegate explicitly.

Some important points about Action:

It doesn't return any value.
It may take zero to 16 parameters.
It can be used with anonymous methods or lambda expressions.

Basic example

static void Main(string[] args)
{
Action<int> myAction = (int x) => Console.WriteLine("Print {0}", x);
Action<int, int> myAction1 = (x, y) => Console.WriteLine("Print {0} and {1}", x, y);
//Execute Method
myAction.Invoke(10);
myAction1.Invoke(20, 10);
Console.ReadKey();
}

Output

Print 10

Print 20 and 10

Action for the short event handlers

mybtnOk.Click += (sender, e) => MessageBox.Show("You have clicked to save!");

Action can be used with "Console.WriteLine"

string myStringValue = "India,USA,UAE,Canada,Singapur,Switzerland";
string[] countries = myStringValue.Split(',');
// Passing WriteLine as the action
Array.ForEach(countries, Console.WriteLine);
Console.ReadKey();

India

USA

UAE

Canada

Switzerland

Anonymous methods can be used with Action

static void Main(string[] args)
{
Action<int> showValue = delegate(int i) { Console.WriteLine(i); };
showValue(10);
Console.ReadKey();
}

Output

Func

Func is also a kind of Delegate that encapsulates a method that has parameter(s) and returns a value of the type specified by the TResult parameter.

Some important points about Func:

It is used to point to a method that returns a value.
It takes up to 16 parameters and returns a value.

The following are the common usage examples of Func Delegate:

Func is being used in LINQ - Projection

static void Main(string[] args)
{
List<Student> students = new List<Student>();
students.Add(new Student { RollNo = 1, Name = "ABC" });
students.Add(new Student { RollNo = 2, Name = "ABC" });
students.Add(new Student { RollNo = 3, Name = "ABC" });
var studentDetails = students.Select(x => x.RollNo);
foreach (var item in studentDetails)
Console.WriteLine(item);
Console.ReadKey();
}

Output

Func is being used in LINQ - Filtering

static void Main(string[] args)
{
List<Student> students = new List<Student>();
students.Add(new Student { RollNo = 1, Name = "Ali" });
students.Add(new Student { RollNo = 2, Name = "Rohan" });
students.Add(new Student { RollNo = 3, Name = "Jon" });
var studentDetails = students.Where(x => x.RollNo == 1);
foreach (var item in studentDetails)
Console.WriteLine(item.Name);
Console.ReadKey();
}

Output: Ali

Func can be used as Key Selection

The following example will co-relate the elements of two sequences based on key.

public class Employee
{
public int EmployeeId { get; set; }
public string Name { get; set; }
}
public class EmployeeSalary
{
public Double Salary { get; set; }
public Employee EmployeeDetail { get; set; }
}

static void Main(string[] args)
{
Employee employeeAli = new Employee { EmployeeId = 1, Name = "Ali" };
Employee employeeRaj = new Employee { EmployeeId = 2, Name = "Raj" };
EmployeeSalary empSalaryAli = new EmployeeSalary { Salary = 2000, EmployeeDetail = employeeAli };
EmployeeSalary empSalaryRaj = new EmployeeSalary { Salary = 80000, EmployeeDetail = employeeRaj };
List<Employee> employee = new List<Employee> { employeeAli, employeeRaj };
List<EmployeeSalary> employeeSalary = new List<EmployeeSalary> { empSalaryAli, empSalaryRaj };
var employeeDetailsQuery = employee.Join(employeeSalary, emp => emp, sal => sal.EmployeeDetail,
(emp, sal) => new { EmployeeName = emp.Name, Salary = sal.Salary });
foreach (var employeeDetail in employeeDetailsQuery)
{
Console.WriteLine("{0} - {1}", employeeDetail.EmployeeName, employeeDetail.Salary);
}
Console.ReadKey();
}

Here, Join has been used as Func.

Output:

Ali - 2000

Raj - 80000

Func can be used to project a sequence of Integer values into a sequence of strings

static void Main(string[] args)
{
// Here, It is a projection.
Func<int, string> myValueDetails = intData => "Value : " + intData;
int[] integerValues = { 1, 2, 3, 4 };
var strings = integerValues.Select(myValueDetails);
foreach (string s in strings)
{
Console.WriteLine(s);
}
Console.ReadKey();
}

Output:

Value : 1

Value : 2

Value : 3

Value : 4

So, in the above code you can see integer value has been projected with string value by using Func.

Predicate

Predicate is a kind of Delegate that represents the method, defines a set of criteria and test whether it is true of given T object.

It is basically reference to a function that return true or false.

Predicate, Predicate<T> is similar to Func<T, bool>. It is very useful and allows us to write logic at run time. Most common usage of predicate are - Filtering a list of values, searching items in a collection, etc.

The following are the examples where Predicate Delegate has been used.

Filter a number

public static bool IsEvenNumber(int number)
{
return number % 2 == 0;
}

static void Main(string[] args)
{
List<int> numbers = new List<int> { 1, 2, 3, 8,11,20 };
Predicate<int> myPredicate = new Predicate<int>(IsEvenNumber);
List<int> evenNumbers = numbers.FindAll(myPredicate);
foreach (var even in evenNumbers)
{
Console.WriteLine(even);
}
Console.ReadKey();
}

Output:

But, C# 3.0 provides a great way to use Predicate. See like the following:

static void Main(string[] args)
{
List<int> numbers = new List<int> { 1, 2, 3, 4, 8, 11 };
List<int> evenNumbers = numbers.FindAll(numb => numb % 2 == 0);
foreach (var evenNum in evenNumbers)
Console.WriteLine(evenNum);
Console.ReadKey();
}

Output:

Conclusion

C# framework provided us a wonderful way to use or define Delegate in the form of Action, Predicate, Func, etc. This provide generic way to create Delegate without explicitly declaring a custom Delegate. It saves our time and effort by not defining our own Delegate types for the same thing.

11 Comments

Join the conversation! Your thoughts help the community grow.

Veaceslav Barbarii9y ago
Excellent explanation! :)
ali Aati9y ago
Nice article, you doing a good job
Subash10y ago
Good
Chandradev Prasad11y ago
Nice example
Former member11y ago
Thanks
Banketeshvar Narayan11y ago
Nice Share
Former member11y ago
Thanks
Humayun Kabir Mamun11y ago
Nice...
Former member11y ago
Thanks
Sourabh Somani11y ago
Nice Article and Cool Explanation
Nilesh Jadav11y ago
Good share