using System;

using System.Linq;

​

public class Program

{

    public static void Main()

    {

        int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

​

        // *** Example 1 *** //

        var evenNumbersStatementLambda =

            numbers.Where( 

                (numFromNumbers) => 

                    { 

                        return numFromNumbers % 2 == 0; // The lambda returns true if the number is even.

                    }

                );

        Console.WriteLine($"evenNumbersStatementLambda: {string.Join(",",evenNumbersStatementLambda)}");

        // *** Example 2 *** //

        var evenNumbersExpressionLambda = numbers.Where( // the lambda can be written more succinctly.

                numFromNumbers =>  // this is an expression lambda, the statement to the right of => is not enclosed in braces. An explicit return statement is not used. 

                numFromNumbers % 2 == 0 // an explicit return is not needed

            );

​

        Console.WriteLine($"evenNumbersExpressionLambda: {string.Join(",",evenNumbersExpressionLambda)}");

​

​

        // *** Example 3 *** //

        string firstName = "Alan";

        string runQuery1 =

            RunQuery( // Call to RunQuery. First parameter to RunQuery is a Func that takes a string parameter and returns a string.

                (fieldToSearch) => // Start of expression lambda, it takes a string parameter.

                    BuildQuery(fieldToSearch, firstName), // This is the body of the expression lambda. It calls BuildQuery (which returns a string)...

                                                                   // The value of fieldToSearch has not been set yet.

                     "FirstName"); // this corresponds to fieldToSearch in RunQuery, it will be passed to the lambda.

​

        Console.WriteLine(runQuery1);

​

​

        // *** Example 4 *** //

        string lastname = "Adams";

        string runQuery2 =

            RunQuery(

                (fieldToSearch) =>

                    $"SEARCH {fieldToSearch}:{lastname}", // This is the body of the expression lambda. It returns a string.

                     "LastName"); // this corresponds to fieldToSearch in the lambda on the line above.

​

        Console.WriteLine(runQuery2);

​

​

        // *** Local Methods *** //

        #region Local methods

        string RunQuery(Func<string, string> func, string fieldToSearch) // fieldToSearch is "FirstName" in Example 1, and "LastName" in Example 2

        {

            return $"Running a query - {func(fieldToSearch)}";

        }

​

        string BuildQuery(string fieldToSearch, string valueToSearchFor)

        {

            return $"SEARCH {fieldToSearch}:{valueToSearchFor}";

        }

        #endregion

​

​

        // *** Example 5 *** //

        ShallowAndDeepMethods shallowAndDeepMethods = new ShallowAndDeepMethods();

        var resultFromShallowAndDeepMethods = shallowAndDeepMethods.Shallow( // Shallow method takes a Func that takes two int parameters and returns a string.

            (a, b) => // The lambda takes two int parameters.

                $"Example 5. Result of a * b ({a} * {b}) is {a * b}", // Expression lambda body performs a simple calculation, and returns a string.

                10, 20 // Two numbers are passed to the Shallow method

            );

        Console.WriteLine(resultFromShallowAndDeepMethods);

​

​

        // *** Example 6 *** //

        OtherMethods otherMethods = new OtherMethods();

        var resultFromOtherMethods = otherMethods.Top( //Top takes a Func that takes two int parameters and returns a string.

            (a, b) =>  // The lambda takes two int parameters.

                $"Example 6. Result of a + b ({a} + {b}) is {a + b}", // Expression lambda body performs a simple calculation, and returns a string.

                5 // Passed to the Top method as num1 

            );

​

        Console.WriteLine(resultFromOtherMethods);

    }

​

}

​

public class OtherMethods

{

    public string Top(Func<int, int, string> func, int num1)

     => Botton((x, y) => func(x, y), num1); // Top method does nothing except call Botton, passing the func and num1(5).

​

    public string Botton(Func<int, int, string> func, int num1)

    {

        int localNumber = 10; 

        return func(num1, localNumber); // num1 and localNumber are passed to the lambda.

    }

}

public class ShallowAndDeepMethods

{

    public string Shallow(Func<int, int, string> shallowFunc, int num1, int num2)

    => Deep( // Call to Deep method, Deep takes a Func that takes a *string* and two int parameters and returns a string.

        (someString, a, b) => // Not going to use the string parameter, could discard it but won't.

         shallowFunc(a, b), // The Func in Deep must return a string, the func passed into shallow does return a string, so it can be used here.

          num1, num2, default(int)); // Pass on num1, and num2. Not passing anything for num3, so using default(int).

​

​

    public string Deep(Func<string, int, int, string> deepFunc, int num1, int num2, int num3)

    {

        // This is where things get a more complicated.

        // Look at the parameters to this method, deepFunc takes a string, and two ints, and returns a string. 

        // But you can see from the Shallow Method, that shallowFunc was passed to Deep as deepFunc, but shallowFunc only takes two ints, and returns a string. 

        // Now to invoke deepFunc, you must pass in a string, and two ints, but the string will be ignored. 

        //var wontWork = deepFunc(100, 200); // This will not work, because deepFunc takes a string, and two ints, and returns a string.

        return $"In Deep: calling func with {num1}, {num2} - {deepFunc("this text will not be used", num1, num2)}";

    }

}

​