Lambda表达式的前世今生

转自： http://www.cnblogs.com/OceanEyes/archive/2012/08/27/linq-2.html

 

 

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

namespace 委托Test
{
    delegate bool FilterDelegate(int i);
    class Program
    {
        static void Main(string[] args)
        {
            int[] array = { 1, 2, 3, 5, 6, 6, 7, 8, 9 };
            List<int> newList = MyFilter(array,FilterOdd);
            foreach (int item in newList)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();

        }
        static List<int> MyFilter(int[] array, FilterDelegate filter)
        {
            List<int> list = new List<int>();
            for (int i = 0; i < array.Length; i++)
            {
                if (filter(i))
                {
                    list.Add(i);
                }
            }
            return list;
        }
        /// <summary>
        /// 偶数
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        static bool FilterEven(int i)
        {
            return i % 2 == 0;
        }
        /// <summary>
        /// 奇数
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        static bool FilterOdd(int i)
        {
            return i % 2 == 1;
        }
    }
}

 

 

//例如
delegate void Del(int x);
....
Del d = delegate(int k) { /* ... */ };

 所以上面例子小小改动一下即可：

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

namespace 委托Test
{
    delegate bool FilterDelegate(int i);
    class Program
    {
        static void Main(string[] args)
        {
            int[] array = { 1, 2, 3, 5, 6, 6, 7, 8, 9 };
            //使用匿名方法来求偶数
            List<int> newList = MyFilter(array, delegate(int i) {

                return i % 2 == 0;
            });
         
            foreach (int item in newList)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();

        }
        static List<int> MyFilter(int[] array, FilterDelegate filter)
        {
            List<int> list = new List<int>();
            for (int i = 0; i < array.Length; i++)
            {
                if (filter(i))
                {
                    list.Add(i);
                }
            }
            return list;
        }
    }
}

 

 

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

namespace 委托Test
{
    delegate bool FilterDelegate(int i);
    class Program
    {
        static void Main(string[] args)
        {
            int[] array = { 1, 2, 3, 5, 6, 6, 7, 8, 9 };
            //使用Lambda表达式来求偶数
            List<int> newList = MyFilter(array, i => i % 2==0);
         
            foreach (int item in newList)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();

        }
        static List<int> MyFilter(int[] array, FilterDelegate filter)
        {
            List<int> list = new List<int>();
            for (int i = 0; i < array.Length; i++)
            {
                if (filter(i))
                {
                    list.Add(i);
                }
            }
            return list;
        }
    }
}

 

 

（请注意，我标注出来的Fun<T,TResult>是一个委托！） 

所以再对上面的Filter进行改进：

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

namespace 委托Test
{
    //delegate bool FilterDelegate(int i);
    class Program
    {
        static void Main(string[] args)
        {
            int[] array = { 1, 2, 3, 5, 6, 6, 7, 8, 9 };
            //使用匿名方法来求偶数
            //List<int> newList = MyFilter(array, delegate(int i) {

            //    return i % 2 == 0;
            //});
            //使用Lambda表达式求偶数
            List<int> newList = MyFilter(array, i => i % 2 == 0);
         
            foreach (int item in newList)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();

        }
        //Func<int,bool>: 封装了一个具有一个int参数并且返回类型为bool类型的方法
        static List<int> MyFilter(int[] array,Func<int,bool> filter)
        {
            List<int> list = new List<int>();
            for (int i = 0; i < array.Length; i++)
            {
                if (filter(i))
                {
                    list.Add(i);
                }
            }
            return list;
        }
    }
}

 

 

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

namespace LambdaDemo
{
    class Program
    {
        static void Main(string[] args)
        {
           
            string[] names = {"Eyes","Voodoo","Tod","Chris","Christina","Maxisim" };
            Func<string, bool> filter = s => s.Length > 5;
            Func<string, string> order = s => s;
            Func<string, string> operating = s => s.ToUpper();

            IEnumerable<string> expr = names.Where(filter).OrderByDescending(order).Select(operating);
            expr.ToList<string>().ForEach(i => Console.WriteLine(i));
            Console.ReadKey();

        }
    }
}

 

 

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

namespace Lambda表达式树
{
    class Program
    {
        static void Main(string[] args)
        {
            //计算(Price-5)*Count*Rebate
            ParameterExpression paraPrice = Expression.Parameter(typeof(decimal),"price");
            ConstantExpression constant = Expression.Constant(5m,typeof(decimal));
            BinaryExpression result1 = Expression.Subtract(paraPrice, constant);

            ParameterExpression paraCount = Expression.Parameter(typeof(decimal),"count");
            ParameterExpression paraRebate = Expression.Parameter(typeof(decimal),"rebate");
            BinaryExpression result2 = Expression.Multiply(paraCount,paraRebate);

            BinaryExpression result3 = Expression.Multiply(result1,result2);
            Expression<Func<decimal, decimal, decimal, decimal>> totalPrice = Expression.Lambda<Func<decimal, decimal, decimal, decimal>>(result3,paraPrice,paraCount,paraRebate);
            Func<decimal, decimal, decimal, decimal> myFun = totalPrice.Compile();
            Console.WriteLine(myFun(125m,10m,0.5m));
            Console.ReadKey();

        }
      
    }
}

 

 

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


namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
         
            Expression<Func<int, int>> f1 = x => x + 1;
            //f1(1)//...错误,必须将表达式树表示的代码编译成一个可执行委托
            Func<int, int> f2 = f1.Compile();
            Console.WriteLine(f2(2));
            Console.ReadKey();
        }
    }
}

 

 

评论

2 楼 北极的。鱼 2014-07-10  

摘录自MSDN
表达式 lambda
表达式位于 => 运算符右侧的 lambda 表达式称为“表达式 lambda”。 表达式 lambda 广泛用于表达式树（C# 和 Visual Basic）的构造。 表达式 lambda 会返回表达式的结果，并采用以下基本形式：
(input parameters) => expression

仅当 lambda 只有一个输入参数时，括号才是可选的；否则括号是必需的。 括号内的两个或更多输入参数使用逗号加以分隔：
(x, y) => x == y

有时，编译器难以或无法推断输入类型。 如果出现这种情况，你可以按以下示例中所示方式显式指定类型：
(int x, string s) => s.Length > x

使用空括号指定零个输入参数：
() => SomeMethod()
在上一个示例中，请注意表达式 Lambda 的主体可以包含一个方法调用。 但是，如果要创建在 .NET Framework 之外计算的表达式目录树（例如，在 SQL Server 中），则不应在 lambda 表达式中使用方法调用。 在 .NET 公共语言运行时上下文之外，方法将没有任何意义。

1 楼 北极的。鱼 2014-07-10  

另外的资料就是MSDN

http://msdn.microsoft.com/zh-cn/library/bb397687.aspx


Lambda表达式就是一个匿名函数，若要创建 Lambda 表达式，需要在 Lambda 运算符 => 左侧指定输入参数（如果有），然后在另一侧输入表达式或语句块。 例如，lambda 表达式 x => x * x 指定名为 x 的参数并返回 x 的平方值。