Delegates, Anonymous Functions and Lambda Expressions in C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Anonymous
{
    class Class1
    {
        public delegate void Vender();

        public static void Milk()
        {
            Console.Write("Milk + ");
        }
 
        public static void Tea()
        {
            Console.Write("Tea = Tea ");
        }
 
        public static void Coffee()
        {
            Console.Write("Coffee = Coffee ");
        }

        static void Main()
        {
            Vender vender = new Vender(Milk);
            Console.WriteLine("\t\tPress 1 For Tea\n\t\t Press 2 For Coffee");
            int Opt = Convert.ToInt32(Console.ReadLine());
            switch (Opt)
            {
                case 1:
                    vender += Tea;
                    break;

                case 2:
                    vender += Coffee;
                    break;

                default:
                    Console.WriteLine("Invalid Option !");
                    Environment.Exit(0);
                    break;
            }

            vender();
            Console.ReadKey();
        }
    }
}

In the above program I just created the three functions, Tea, Coffee and Milk. When one is pressed there will be two functions, called Milk and Tea. If the user chooses both then again the two functions, Milk and Coffee are called. Since Milk is common to both situations I just pass Milk in the Delegate parameter. And the delegate understands "+" and "+=" for adding references of functions and "-" and "-=" for removing function references, so dependng on the option used I just add a function reference with the same Delegate obeject vender. And invoke the delegate vender.

6. Action<T> and Func<T> Delegates

Instead of creating your own delegate for deffrent parameters and return type you can use a predefined Func<T> and Action<T> delegate that is decleaed in the System namespace that is declared of 16 types with different parameters.

7. Delegate Evolution

• In C# 1.0 you create a delegate instance and initialize with a method reference.

• C# 2.0 introduced Anonymous methods that can be executed with delegate invocation.

• Then in C# 3.0, lambda expressions are similar in concept to anonymous methods but more expressive and conches.

These two concepts are collectively known as anonymous functions. An anonymous function is a block of code that can be used as a delegate type as a method parameter.

There are two kinds of anonymous functions:

1. Anonymous method

2. Lambdas expression

8. Anonymous Method

In C# 1.0 you can use a delegate and pass a function reference with an initializing delegate with a function name, but C# 2.0 introduced anonymous functions.

Creating an anonymous method as an inline block of code to be passed as a delegate parameter can be done as you see in the following:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Anonymous
{
    class Class1
    {
        public delegate void Del();

        static void Main(string[] args)
        {
            Del obj = delegate() {
                Console.WriteLine( "Class1.fun");
            };

            obj();
        }
    }
}

Use of an anonymous function can reduce the lines of code. So, here in the program above you can see I just passed a block of code for a delegate parameter inside of creating a function anywhere else and passing the function name. The anonymous function uses the delegate keyword while delegate initialization writes a block of code. You can also pass a parameter for an anonymous function as follows:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Anonymous
{
    class Class1
    {
        public delegate void Del( string Mesg);

        static void Main(string[] args)
        {
            Del obj = delegate(string Mesg) {
                Console.WriteLine(Mesg);
            };

            obj("Class1.fun");
        }
    }
}

Note:

You cannot use goto, break and continue statements inside the anonymous method block if the targat is outside an anonymous block.

9. Lambda Expressions

A Lambda expression is an anonymous function that you can use to create a delegate. Lambda expressions are very useful for writing LINQ queries. For creating a lambda expression you can use the following santax:

(<Paramter>) => { expression or statement; }

If there is any parameter thenb you can specify parameters on the left side of the lambda operator => and put all your expressions or santax on another side. For example:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Anonymous
{
    class Class1
    {
        public delegate int Del( int Value);

        static void Main(string[] args)
        {
            Del obj = (Value) => {
                int x=Value*2;
                return x;
            };
            Console.WriteLine(obj(5));
        }
    }
}

Parentheses are optional only if the lambda expression holds more than one parameter the same as if the lambda expression has only a single statement. Curly brakets are also optional; that means you can alternatively write the program above in the following format:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Anonymous
{
    class Class1
    {
        public delegate int Del( int Value);

        static void Main(string[] args)
        {
            Del obj = Value => Value*2;
            Console.WriteLine(obj(5));
        }
    }
}

In the above program you need to notice two things first, there is no return statement in the lambda expression but the delegate Del has a return type as int and the second thing is that I just did not specify any type for the Value variable so in such a situation the lambda expression will be converted into that type implicitly. This conversion is the concept of Type inference as I explained in http://www.c-sharpcorner.com/UploadFile/d6fefe/all-about-generics/.

It is sometimes impossible for the compiler to infer the type of parameters so for that you can specify the type of a parameter, as you can see in the following example:

(int Value1, string Value2) => Value2.Length * Value1;

If there is not a parameter then you need to use blank parenthesis as in: "() => expression;".

10. Variable scope with lambda expression

With lambda expressions you can access a variable declared outside the block of the lambda expression. Here you will wonder how lambda expressions will access the outer variable. Actually the compiler creates an Anonymous class and creates a constructor that takes parameters depending on how many outer variables you used in the lambda expression and creates an anonymous function for declaring the lambda expression as in the following:

class Anon_Class
{
public int Value;
 
public Anon_Class(int Value)
{
    this.Value=Value;
}

public int Anon_Fun(int x)
{
   return x*2;
}

}

But when accessing the outer variable inside the lambda expression, cases can be a problem if you do not use them correctly.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Anonymous
{
    class Class1
    {

        delegate bool Del(int z);
        delegate bool Del2(int z);
        Del2 del2;
        public void Init(int Value)
        {
            int j = 0;

            Del del = (x) => { j = 12; return x == j; };
            del2 = (x) => {return Value == j; };

            Console.WriteLine("j = {0}", j);

            bool Res = del(12);

            Console.WriteLine("j Value= {0} and Res = {1}", j, Res);
        }

        static void Main()
        {
            Class1 class1 = new Class1();
            class1.Init(12);

            //here res will be True Becouse there will be a copy of j variable //with value 12 where as j is local variable

            bool res=class1.del2(12);
            Console.WriteLine("res = "+res);
            Console.ReadKey();
        }
    }

}

The program above will be confusing about the value of the variable j. We cannot recognize which time and where, what value j has. A variable that is captured will not be garbage-collected until the delegate that references it goes out of scope. There are some more rules with lambdas that's defined with an anonymous method as you cannot use a go to, continue and break statement if its target is outside the block.

11. End of the article

You can use lambda expressions in your program where you need to pass a parameter as a delegate. Another use of lambdas is with Expression and Expression<T> classes, for which the compiler creates an expression tree. I intend to write an article for Tree Expression in C# as soon as possible.