Delegates (Delegate, Func, Predicate, Action and Lambda)

  

Introduction

In this article I am going to describe some confusing terms including Func, Action, Predicate, lambda expression and delegate and their differences. Although the introduction of generics and lambda expressions added a bit to the complexity of these terms, they are all the same, Delegates.

This helps you to have a better understanding of these terms and could possibly solve complex interactions between objects and collections.

Background

Delegate has existed in the programming world since a long time ago, however throughout the time many forms of delegates have been added to .Net for the purpose of creating more ways to solve problems.

Let's start with a simple definition of delegates. A delegate is a reference to a piece of code that does something!, exactly like a method. It has arguments as input and results as output.

Hide   Copy Code

delegate(int x) {    return x == 0;
}

If we replace the delegate keyword with 

Hide   Copy Code

public bool FunctionName

then it would become

Hide   Copy Code

public bool FunctionName(int x){    return x == 0;
}

so basically in one form it could be a function without a name and more technically an anonymous function. A delegate can also have a name like below and it refers to a method with the same signature.

Hide   Copy Code

public bool delegate Name(int x);

and then this could be associated with an event so that other objects can subscribe to it and be notified whenever the event is fired (which is out of scope for this article).

Now that we know what a delegate is, let's use it somewhere exciting such as LINQ and collections. Say we have a collection like this:

Hide   Copy Code

var collection = new List<int>();
collection.Add(1);
collection.Add(2);
collection.Add(3);

If we want to filter the elements of this collection, we normally write something like:

Hide   Copy Code

collection.Where(x => x == 2);

I will get back to lambda expressions and explain them as part of this article.

Delegate

Now what if I want to describe the condition inside parenthesis with a delegate. Remember a delegate is supposed to reference to a piece of code that does something so basically like a method. So why not comparing some elements and filter them for us, like the lambda expression that I talked about. So what if I write something like:

Hide   Copy Code

delegate(int item)
{    if(item == 2)
    {        return true;
    }    return false;
}

and subsequently:

Hide   Copy Code

collection.Where(delegate(int item)
            {                if (item == 2)
                {                    return true;
                }                return false;
            });

How was that? So simply this was a delegate which was taking an integer as an input and was returning a boolean as output.

Func

Another form of a delegate is Func. Func could have any number and type of input arguments and could return any type of output, exactly like a delegate. The signature is something like:

Hide   Copy Code

Func<int, bool> condition = delegate(int item)
{    if(item == 2)
    {        return true;
    }    return false;
};

Because Func could return any type, we need to mention the return type in the signature (in this case the bool, which is literrally the last argument in the generic definition.

Hide   Copy Code

Func<int, bool> condition = deleg...

And I can write:

Hide   Copy Code

var result = collection.Where(condition);

Predicate

If a Func only returns a bool, that would have another name called a Predicate, just to confuse us a bit more. So a predicate is a delegate that always returns a boolean with any number and type of inputs. Therefore:

Hide   Copy Code

Predicate<int> predicate = delegate(int item)
{    if(item == 2)
    {        return true;
    }    return false;
};

However we need to convert this predicate to a Func if we want to use it like before:

Hide   Copy Code

Func<int, bool> condition = new Func<int, bool>(predicate);
collection.Where(condition);

But there are situations that we could use a predicate directly:

Hide   Copy Code

collection.Find(predicate);

Best Practice: Use Func, Lambda Expressions and Delegates instead of Predicates.

Action

Now what if my Func didn't return any value, what would be that called then? Yes! an Action. So basically an Action is a delegate that does something without any return value. Something like:

Hide   Copy Code

Action<int> action = delegate(int item)
{
    item += 2;
}

Can I use this action with the previous example of filtering? Not really, because the argument to the Where method should return a boolean to evaluate whether that item should be included in the result or not, right? So Where can I use an Action?

The answer is whenever I wanted to do an operation without any return value. like:

Hide   Copy Code

collection.ForEach(action);

So this will run for every item in the collection and adds 2 to each item. However note that although this action is run for each item in the collection, in this case the change is not applied because we are modifying a collection using a LINQ for each loop which is not allowed. But it was a Reference type, properties of that type could be changed in a for each loop, like the samples below.

Lambda Expression

Now I'd like to define another synonym for a delegate, a Lambda Expression. A lambda expression can be in the form of a Func or an Action, and therefor inherently it's a delegate. 

So the replacement for the Where argument could be:

Hide   Copy Code

Predicate<int> condition = (int x) => x == 2;
Func<int, bool> condition = (int x) => x == 2;

and for the ForEach method I can write:

Hide   Copy Code

Action<int> action = (int item) => item += 2;

And that's it. We are there, with all the confusion gone. I have written some samples below for each of these terms in a more complicated fashion. Hope it helps.

Samples

Hide   Copy Code

public class Customer
{    public string Name { get; set; }    public string Telephone { get; set; }
}

Hide   Copy Code

var customers = new List<Customers>();

customers.Add(new Customer() {
    Name = "cust A",
    Telephone = "123"});

Hide   Copy Code

customers.Add(new Customer() {
    Name = "cust B",
    Telephone = "456"});

Hide   Copy Code

customers.Add(new Customer() {
    Name = "cust C",
    Telephone = "789"});

1. Delegate 

Hide   Copy Code

customers.Where(delegate(Customer cust) {    return cust.Name == "cust B";
});

2. Func

Hide   Copy Code

Func<Customer, bool> filter = delegate(Customer cust){    return cust.Name == "cust B";
};

customers.Where(filter);

3. Predicate

Hide   Copy Code

Predicate<Customer> filter = delegate(Customer cust){    return cust.Name == "cust B";
};

customers.Find(filter);

4. Lambda

Hide   Copy Code

Func<Customer, bool> filter = (Customer cust) => cust.Name == "cust B";

customers.Where(filter);

5. Action

Hide   Copy Code

We can't use Actions here because it doesn't return any value let alone bool.

Now lets play with ForEach method, instead of filtering data:

1. Delegate

Hide   Copy Code

customers.ForEach(delegate(Customer cust){
    cust.Name = "cust B name Modified !!!";
});

2. Func

Hide   Copy Code

We can't use Func here, as Func has to always return something.

3. Predicate

Hide   Copy Code

We can't use predicate here as well, as it always has to return boolean.

4. Lambda

Hide   Copy Code

customers.ForEach(cust => cust.Name = "cust B Modified !!!");

5. Action

Hide   Copy Code

Action<Customer> filter = (Customer cust) => cust.Name = "cust B Modified !!!";

customers.ForEach(filter);

*) Now a key question! why the following code snippet has a compilation error:

Hide   Copy Code

var simpleDelegate = delegate(int x) {    return x == 0;
};