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:

1. Action
2. Func
3. Predicate
4. Lambda
5. 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:

1. It doesn't return any value.
2. It may take zero to 16 parameters.
3. 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

 

10

 

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:

1. It is used to point to a method that returns a value.
2. 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

1

2

3

 

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:

2

8

20

 

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:

2

4

8

 

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.