Lambda exp, Func generic delegate, Action generic delegate, and Predicate generic delegate   Leave a comment

Lambda expression, Funct generic delegate, Action generic delegate, and Predicate generic delegate make your delegate code more simple.

Lambda expression helps to build expression tress -> LINQ, BL (Business Language).

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
using System.Data;
using System.Linq;
using System.Linq.Expressions;

namespace ConsoleApplication2
{
    class Program
    {
        //Lambda expression, Funct generic delegate, Action generic delegate, and Predicate generic delegate make your delegate code more simple
        //Lambda expression helps to build expression tress -> LINQ, BL (Business Language)
        delegate double delCal(int r);
        delegate int delSum(int x, int y);
        static void Main(string[] args)
        {
            //1)
            /**********Lambda expression, Funct generic delegate, Action generic delegate, 
            and Predicate generic delegate make your delegate code more simple************/

            //Simple delegate
            delCal dc = CalArea;
            double Area = dc.Invoke(20);
            //End

            //Anonymous function
            delCal dCal = new delCal(delegate(int r){return 3.14 * r * r;
            }
            );
            double Area2 = dCal.Invoke(20);
            //End

            //Lambda expression -> (input parameters) => expression
            delCal dCalL = r => 3.14 * r * r;
            double Area3 = dCalL.Invoke(20);

            delSum delsum = (x, y) => { x = x + 10; y = y + 10; return x + y; };
            int sum = delsum.Invoke(10, 10);
            //End

            //Lambda + Func => Func is used when we want to pass input and get the out of any type.
            Func delFun = r => 3.14 * r * r;
            double delFunArea = delFun.Invoke(20);
            //End
            
            //Action => It take input but doesn't return output.
            Action oAction = O => Console.WriteLine(O);
            oAction.Invoke("Hello World");
            //End
            
            //Predicate => Used when function should return either True or False value to take further decision or action.
            Predicate oPredicate = O => O.Length > 4;
            bool bl = oPredicate.Invoke("Izhar");
            //End

            //2)
            /**************Lambda expression helps to build expression tress -> LINQ, BL (Business Language)************/

            //Example: (10+15)-(10+5)
            //http://www.codeproject.com/Articles/19154/Understanding-LINQ-C
            BinaryExpression be1 = Expression.MakeBinary(ExpressionType.Add, Expression.Constant(10), Expression.Constant(15));
            BinaryExpression be2 = Expression.MakeBinary(ExpressionType.Add, Expression.Constant(10), Expression.Constant(5));
            BinaryExpression be = Expression.MakeBinary(ExpressionType.Subtract, be1, be2);

            int intResult = Expression.Lambda<Func>(be).Compile()();
            //End
        }

      
        static double CalArea(int r) {
            return 3.14 * r * r;
        }
    }
}
Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

w

Connecting to %s

%d bloggers like this: