using System;

using System.Collections.Generic;

​

// Anatomy of the Lambda Expression

// http://www.tutorialsteacher.com/linq/linq-lambda-expression

​

public class Program

{

    public static void Main()

    {

        /* C# 3.0(.NET 3.5) introduced the lambda expression along with LINQ. 

        The lambda expression is a shorter way of representing anonymous method using some special syntax.

​

        For example, following anonymous method checks if student is teenager or not:

        Anonymous method in C#: delegate(Student s) { return s.Age > 12 && s.Age < 20; };   */

        IsTeenAger isTeenAger = delegate(Student s) { return s.Age > 12 && s.Age < 20; };

        /* The Lambda expression in C#: s => s.Age > 12 && s.Age < 20     

        "s" is the parameter.

         "=>" is the Lambda operator

         "s.Age > 12 && s.Age < 20;" is the Body Expression

        */

        Student stud = new Student() { Age = 25 };

        Console.WriteLine(isTeenAger(stud)); // False

        IsTeenAger isTeenAger2 = s => s.Age > 12 && s.Age < 30;

        Console.WriteLine(isTeenAger2(stud)); /* True

        --------------------------------------------

        Lambda Expression with Multiple parameters:

        You can wrap the parameters in parenthesis if you need to pass more than one parameter, as below:

        Example: Specify multiple parameters in lambda expression C#

        (s, youngAge) => s.Age >= youngage;     

        */

​

        IsYoungerThan isYoungerThan = (s, youngAge) => s.Age < youngAge;

​

        Student stud2 = new Student() { Age = 25 };

​

        Console.WriteLine(isYoungerThan(stud2, 26));

        /*  You can also give type of each parameters if parameters are confusing:

        Example: Specify parameter type in lambda expression C#

        (Student s,int youngAge) => s.Age >= youngage;      

        ----------------------------------------------

        ----------------------------------------------

        Lambd expression without any parameter:

        It is not necessary to have atleast one parameter in a lambda expression. 

        The lambda expression can be specify without any parameter also. */

​

        Print print = () => Console.WriteLine("This is parameter less lambda expression"); 

        print();            /*

        -------------------------------------------------------

​

        ----------------------------------------------

        Multiple statements in body expression:

        You can wrap expressions in curly braces if you want to have more than one statement in the body:*/

        IsYoungerThan isYoungerThan2 = (s, youngAge) => {

​

            Console.WriteLine("Lambda expression with multiple statements in the body");

            return s.Age < youngAge;

        };

        Student stud3 = new Student() { Age = 25 };

        Console.WriteLine(isYoungerThan(stud3, 26)); /*

        ----------------------------------------------

        ----------------------------------------------

        Local variable in Lambda Expression body:

        You can declare a variable in the expression body to use it anywhere in the expression body, as below: */

        IsAdult isAdult = (s) => {

            int adultAge = 18;

​

            Console.WriteLine("Lambda expression with multiple statements in the body");

            return s.Age >= adultAge;

        };

        Student stud4 = new Student() { Age = 25 };

        Console.WriteLine(isAdult(stud4)); /*

        ----------------------------------------------

        ----------------------------------------------

        Lambda expression can also be assigned to built-in delegates such as Func, Action and Predicate.

        Func Delegate:

​

        Use the Func<> delegate when you want to return something from a lambda expression. The last parameter type in a Func<> delegate is the return type and rest are input parameters. Visit Func delegate section of C# tutorials to know more about it.

        Consider the following lambda expression to find out whether a student is a teenager or not.

        Example: Lambda expression assigned to Func delegate in C#*/

        Func<Student, bool> isStudentTeenAger = s => s.Age > 12 && s.Age < 20;

        Student stud5 = new Student() { Age = 21 };

        Console.WriteLine(isStudentTeenAger(stud5));

        /*In the above example, the Func delegate expects the first input parameter to be of 

        Student type and the return type to be boolean. 

        The lambda expression s => s.age > 12 && s.age < 20 

        satisfies the Func<Student, bool> delegate requirement. 

        The Func<> delegate shown above, is the equivalent of a function as shown below.

​

        bool isStudentTeenAger(Student s)

        {

            return s.Age > 12 && s.Age < 20;

        }

        -------------------------------------------------------- 

        -------------------------------------------------------- 

        Action Delegate:

        Unlike the Func delegate, an Action delegate can only have input parameters. Use the Action delegate type when you don't need to return any value from lambda expression.

        Example: Lamda expression assigned to Action delegate in C#     */

        Action<Student> PrintStudentDetail = s => Console.WriteLine("Name: {0}, Age: {1} ", s.Name, s.Age);

​

        Student std = new Student(){ Name = "Bill", Age=21};

​

        PrintStudentDetail(std); /*

        ------------------------------------------------------------------- */

    }

}

​

class Student

{

    public int StudentID { get; set;}

    public String StudentName { get; set;}

    public int Age { get; set;}

    public string Name { get; set; }

    public int Id { get; set; }

}

​

delegate bool IsTeenAger(Student stud);

​

delegate bool IsYoungerThan(Student stud, int youngAge);

​

delegate void Print();

​

delegate bool IsAdult(Student stud);

​