Delegate and Lamda expression in C#

The delegate is a reference type data type that defines the method signature and similar to function pointer in C/C++.  It is declared in the following way:

[access modifier] delegate [return type] [delegate name]([parameters])

access modifier can be public, private etc

Here are few examples:

public delegate int MyDelegate(int x, int y);  //We can assign a function that takes 2 integer parameters and return type is integer
public delegate string MyDelegate(string firstname, int id); //We can assign a function that takes 2 parameters (first one string and second one integer) and return type is string.

public  delegate void MyDelegate(string message);
MyDelegate del = new MyDelegate(ArealMethod);
// or 
MyDelegate del = ArealMethod; 
// or set lambda expression  will be explained later
MyDelegate del = (string msg) =>  Console.WriteLine(msg);
// target method
static void ArealMethod(string message)
{
    Console.WriteLine(message);
}

Complete example:

    public class myApp
    {
        public delegate int MyDelegate(int x, int y);
        public static void Main()
        {
            MyDelegate del = new MyDelegate(Add);
            //Can be re written in the following way as well, compiler does the rest.
            int result = del(3, 4);
            Console.WriteLine(result); // the output will be 7, not a big deal

            del = Sub;
            result = del(3, 4);
            Console.WriteLine(result); // the output will be -1, not a big deal

            result = del.Invoke(10, 8); //Call the method by using Invoke
            Console.WriteLine(result);
            del = null;
            del += Add; //Method chain
            del += Sub;
            result = del.Invoke(14, 8); //Call the method by using Invoke, first it will call Add and then it will call Sub
            Console.WriteLine(result);

            Console.ReadKey();
        }
        public static int Add(int x, int y)
        {
            return x + y;
        }

        public static int Sub(int x, int y)
        {
            return x - y;
        }
    }

The output of the above program will be: If you see del has been set to null and then it has been chained with Add and Sub. When we do a chain then always the return value of the last method is returned.

7  
-1
2
6

Anonymous Method:

An anonymous method is a method without a name. Anonymous methods in C# can be defined using the delegate keyword.

Now in the above example, we can shorten the Add method by implementing it locally. This local implementation of the method without name, we call it anonymous method.

        public delegate int MyDelegate(int x, int y);
        public static void Main()
        {
            MyDelegate del = delegate (int x, int y)
            {
                return x + y;
            };
            int result = del(3, 4);
            Console.WriteLine(result); // the output will be 7, not a big deal
            Console.ReadKey();
        }
    }

As we see that content of Add method has been used locally  and the name Add has been removed, still we get the same result.

Lamda Statement:

It shorten further, remove delegate  keyword, put lamda expression symbol (=>) and remove return value, even variable type can be removed.

    public class myApp
    {
        public delegate int MyDelegate(int x, int y);
        public static void Main()
        {
            MyDelegate del =  (int x, int y) =>  x + y;
            int result = del(3, 4);
            Console.WriteLine(result); // the output will be 7, not a big deal
            Console.ReadKey();
        }
    }

If we remove the variable type, we can re write as follows:

MyDelegate del =  (x, y) =>  x + y;

If the original method Add had no parameter then we could have written as 

MyDelegate del =  () =>  10; //just return 10

    public class myApp
    {
        public delegate int MyDelegate();
        public static void Main()
        {
            MyDelegate del = () => 10;
            int result = del();
            Console.WriteLine(result); // the output will be 10
            Console.ReadKey();
        }
    }

Now MyDelegate returns void

    public class myApp
    {
        public delegate void MyDelegate();
        public static void Main()
        {
            MyDelegate del = () => Console.WriteLine("Now I am empty"); 
            del();
            //Console.WriteLine(result); // the output will be 7, not a big deal
            Console.ReadKey();
        }
    }

Same code written as multiline function this is called lamda statement.

 public class myApp
    {
        public delegate void MyDelegate();
        public static void Main()
        {
            MyDelegate del = () =>
            {
                Console.WriteLine("Now I am empty");
            };
            del();
            Console.ReadKey();
        }
    }

Expression lambda

If the right side of a lambda expression carries an expression tree then this kind of lambda expression is called an expression lambda. Yes, the example that we have see just now is one example of an expression lambda. Here is another one.

    //Lamda expression where we have only expression as shown in the following example
    public class myApp
    {
        public delegate bool MyDelegate( int x);
        public static void Main()
        {
            MyDelegate del = (x) =>
            {
                return x > 200;
            };
            Console.WriteLine(   del(29));
            Console.ReadKey();
        }
    }

Statement lambda

A statement lambda will contain a statement in the right hand side of the lambda expression. Have a look at the following example.

        MyDelegate del = () =>
        {
            int localvar = 200;
            Console.WriteLine("Now I am empty");
            Console.WriteLine("Now I am empty with {0}", localvar);
        };
        del();

Action, Func and Predicate are special type of lamda expression:

Action is a delegate (pointer) to a method, that takes zero, one or more input parameters, but does not return anything where as Func always return a value.

Func is a delegate (pointer) to a method, that takes zero, one or more input parameters, and returns a value (or reference). The last parameter is the return value.

Predicate is a special kind of Func often used for comparisons.

Though widely used with Linq, Action and Func are concepts logically independent of Linq.

Here is a small example for Action and Func without using Linq:

class Program
{
    static void Main(string[] args)
    {
        Action<int> myAction = new Action<int>(DoSomething);
        myAction(123); // Prints out "123"
        // can be also called as myAction.Invoke(123);
        Func<int, double> myFunc = new Func<int, double>(CalculateSomething);
        Console.WriteLine(myFunc(5));   // Prints out "2.5"
    }
    static void DoSomething(int i)
    {
        Console.WriteLine(i);
    }
    static double CalculateSomething(int i)
    {
        return (double)i/2;
    }
}

The Predicate delegate represents the method that defines a set of criteria and determines whether the specified object meets those criteria. In the following example, filtered will be a list of integer with positive numbers.

    //Predicate

    public class myApp
    {
        public static void Main()
        {
            var data = new List<int> { 1, -2, 3, 0, 2, -1 };
            var predicate = new Predicate<int>(isPositive);
            var filtered = data.FindAll(predicate);
            Console.WriteLine(string.Join(",", filtered));
            Console.ReadKey();
        }
        static bool isPositive(int val)
        {
            return val > 0;
        }
    }

Download the sample.

Events in C#

Events are user actions such as keypress, clicks, mouse movements, etc., or some occurrence such as system generated notifications. Applications need to respond to events when they occur. For example, interrupts. The events are declared and raised in a class and associated with the event handlers using delegates within the same class or some other class. The class containing the event is used to publish the event. This is called the publisher class. Some other class that accepts this event is called the subscriber class. 

In C#, the event is implemented with the help of a delegate. One of the most important properties of the delegate is that method chain. Several methods can be chained with delegates provided if those methods have the same signature.

 class Program
    {
        public delegate int MyDelegate(int x, int y);
        public static void Main()
        {
            MyDelegate readyforChained = new MyDelegate(Add);
            readyforChained += Sub;
            readyforChained += Multi;
            int x = readyforChained(10, 5); //only return the last method's return value
            Console.WriteLine("readyforChained returns {0}", x);
            Console.ReadKey();
        }
        public static int  Add(int x, int y)
        {
            Console.WriteLine("Add");
            int z = x + y;
            return z;
        }
        public static int Sub(int x, int y)
        {
            Console.WriteLine("Sub");
            int z = x - y;
            return z;
        }
        public static int Multi(int x, int y)
        {
            Console.WriteLine("Multi");
            int z = x * y;
            return z;
        }
    }

Add
Sub
Multi
readyforChained returns 50

public class ResultChecker
{
    public delegate int MyDelegate ( int x, int y );
    public MyDelegate OnSomeAction { get; set; }
    public int RaiseEvent ( int x, int y )
    {
        int result = 0;
        if (OnSomeAction != null)
        {     
            result = OnSomeAction (x, y );
        }
        return result;
    }
}
    class Program
    {
        public static void Main()
        {
            ResultChecker checker = new ResultChecker();
            checker.OnSomeAction +=  (x, y) => { Console.WriteLine("Add"); return x + y; };
            checker.OnSomeAction += (x, y) => { Console.WriteLine("Sub"); return x + y; };
            checker.OnSomeAction += (x, y) => { Console.WriteLine("Multi"); return x * y; };
            Console.WriteLine(checker.RaiseEvent(30, 20));
            //Call all assigned method  by delegate
            checker.OnSomeAction(20, 3);
            checker.RaiseEvent(3, 5);
            Console.ReadKey();
        }
    }

Add
Sub
Multi
600
Add
Sub
Multi
Add
Sub
Multi

The above text will be output of the program. Now we turn the example by introducing event. The event is just a glorified delegate.

        public class ResultChecker
        {
            public delegate int MyDelegate(int x, int y);
            public event MyDelegate OnSomeAction;
            public int RaiseEvent(int x, int y)
            {
                int result = 0;
                if(OnSomeAction != null)
                {
                    if(x >= 100 && y >= 100)
                    {
                        result = OnSomeAction(x, y);
                    }
                }
                return result;
            }
        }
        public class myApp
        {
            public static void Main()
            {
                ResultChecker checker = new ResultChecker();
                checker.OnSomeAction += (x, y) => { Console.WriteLine("Add"); return x + y; };
                checker.OnSomeAction += (x, y) => { Console.WriteLine("Sub"); return x + y; };
                checker.OnSomeAction += (x, y) => { Console.WriteLine("Multi"); return x * y; };
                checker.OnSomeAction += checker_OnSomeAction;
                Console.WriteLine(checker.RaiseEvent(60, 10)); // does not call method
                Console.WriteLine(checker.RaiseEvent(600, 100));
            }
            static int checker_OnSomeAction(int x, int y)
            {
                Console.WriteLine("Div"); return (int)(x / y);
            }
        }

Introducing EventArgs to indicate who is generating the event.    

        public class NumberArgs:EventArgs
        {
            public NumberArgs(int _x, int _y)
            {
                x= _x;
                y= _y;
            }
            public int x { get; set; }
            public int y { get; set; }
        }
        public class ResultChecker
        {
            public delegate void EventHandler(object sender, EventArgs e);
            public event EventHandler OnSomeAction = delegate { };
            public void CallMethod(int x, int y)
            {
                if(x >= 100 && y >= 100)
                {
                    OnSomeAction(this, new NumberArgs(x, y)); 
                }
            }
        }
        public class myApp
        {
            public static void Main()
            {
                ResultChecker checker = new ResultChecker();
                checker.OnSomeAction += checker_OnSomeAction;
                checker.CallMethod(600, 100);
            }
            static void checker_OnSomeAction(object sender, EventArgs e)
            {
                Type type = sender.GetType();
                Console.WriteLine("type = {0}", type.ToString());
                if(e == EventArgs.Empty)
                {
                    Console.WriteLine("Event argument is null");
                }
                else
                {
                    Console.WriteLine("Event argument is not null");
                }
            }
        }