lamba表达式的个人见解

最新推荐文章于 2025-05-05 17:53:54 发布

weixin_30546933

最新推荐文章于 2025-05-05 17:53:54 发布

阅读量85

点赞数

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/enuo/archive/2011/10/08/2202296.html

本文详细介绍了Lambda表达式的概念、用法和常见应用场景，包括与委托、匿名方法的联系，以及如何与泛型结合使用。重点阐述了Lambda表达式简化代码、作为方法体的功能，以及在集合类型操作中的优势。同时，通过实例展示了Lambda表达式的类型推断和与ORM框架查询的紧密关联。

Lambda 表达式”是一个匿名函数，它可以包含表达式和语句，并且可用于创建委托或表达式树类型。

所有 Lambda 表达式都使用 Lambda 运算符 =>，该运算符读为“goes to”。该 Lambda 运算符的左边是输入参数（如果有），右边包含表达式或语句块。Lambda 表达式 x => x * x 读作“x goes to x times x”。可以将此表达式分配给委托类型，如下所示：

 delegate int del(int i,int j);
        static void Main(string[] args)
        {
            del myAdd=(x,y)=>x+y;
            int j = myAdd(1, 2);
            Console.WriteLine(j);
        }

这里Lambda 表达式用于创建委托.

下面看下创建表达式树类型

 public delegate int myAdd(int x,int y);
        static void Main(string[] args)
        {

            Expression<myAdd> myET = (x,y) => x+y;
            Console.WriteLine(myET.Compile()(1, 2));
        }

对于表达式树类型,这里不作详细介绍!他的主要功能是对表达式作一些处理!

看完上面的例子,大体上可以知道lamba表达式是和委托,匿名方法联系在一起的!

以我的认识角度来看,完全可以把lamba表达式看作一个方法体!他有参数,有表达式或者语句块!或者说他本身就是一个函数,只不过他做了一些简写!

lamba表达式比较常见的用法是和范型一起使用.请看下面的例子:

        public delegate T mySum<T>(T x, T y);
public delegate void myPrint<T>(mySum<T> mysum);
static void Main(string[] args)
        {
            Show((x, y) => (x + y), (f) => { Console.WriteLine(f(11,22)); });
        }
static void Show(mySum<int> test,myPrint<int> print)
        {
            Console.WriteLine("mySum is " + test(11, 22));
            Console.Write("myPrint is " );
            print((x, y) => x + y);
        }

刚开始可能这个例子有些复杂,仔细分析下还是比较简单,首先声明两个委托,一个是通常的参数,一个是委托类型参数,其实委托类型参数和通常的参数都看成参数更易于理解,我们需要习惯于委托这种变量把他和一般的变量同等看待!然后声明一个Show的方法,有两个参数.当我们去调用时,委托类型参数直接传递lamba表达式就行了!这里再次看出lamba表达式就是委托,就是方法体!

在看下面一个例子

   public delegate T1 mySum<T1,T2>(T1 x, T2 y);

static void Main(string[] args)
        {
            Show((x,  y) => ((int.Parse(x.ToString()) + int.Parse(y.ToString())).ToString()));
            Show((x, y) => (int.Parse(x.ToString()) + int.Parse(y.ToString())));
        }
static void Show(mySum<string, string> test)
        {
            Console.WriteLine("mySum is " + test("11", "22"));
        }
static void Show(mySum<int,int> test)
        {
            Console.WriteLine("mySum is " + test(11, 22));
        }
//static void Show(mySum<int, string> test)
//{
//    Console.WriteLine("mySum is " + test(11, "22"));
//}

从这个例子看出lamba表达式的类型推断非常明显的第一个show将调用string参数的方法,第二个将会调用int参数的方法.类型推断包括了参数的类型和返回值类型.如果将注释部分打开的话就会出现编译错误.

编译器无法认知将调用哪个方法!

在实际的使用中lamba表达式大多都是应用于ORM框架里的查询的!更确切地说,是应用于集合类型的筛选与查找!linq给我们提供了许多的扩展方法,像select,where,take之类的很多.而这些方法的参数都是委托!

所以大部分时候,都是写lamba表达式的!而我在这里想说的是,我们只是传递一个方法体!里面的具体实现我们并不清楚.

请看下面的例子:

 static void Main(string[] args)
        {
            List<int> lists = new List<int>();
            lists.Add(1); lists.Add(3); lists.Add(7); lists.Add(5); lists.Add(4); lists.Add(19); lists.Add(2);
            lists=lists.MyWhere(c => { if (c > 5) { return c; } return 0; });
foreach (var item in lists) 
            {
                Console.WriteLine(item);
            }
        }

    }

public static class MyExtension
    {
public delegate T myFilter<T>(int i);
public static List<int> MyWhere(this List<int> lists, myFilter<int> myfilter) 
        {
            List<int> newlists = new List<int>();
foreach (var item in lists) 
            {
if (myfilter(item) != 0)
                {
                    newlists.Add(myfilter(item));
                }
            }

return newlists;
        }
    }