LinQ—Lambda表达式

概述

   本篇博客主要讲解 lambda表达式，在这里将它的来龙去脉，主要是从委托，匿名函数这些方面过度讲的，当然，在讲委托和匿名函数的时候，主要是从Lambda的角度出发讲的，可能它们还具有其它的一些作用或用途，但这已不是本篇博客的重点了，好了接下来我们开始。

 

委托

 概念

    委托就是一个指针变量，一个存放一类方法的指针变量。

 好处

    委托给我们变成带来了什么好处呢？举个例子：BLL层里面有一个类A，一个类B，类A中有a方法，类B中有b方法，我们要想实现a方法中调用b方法，方式有两种。

    一种是在a方法中直接调用b方法；另一种是a方法直接调用委托x(看上面的委托定义)，然后，在U层中，当我们使用A类的a方法时，再将B类的b方法赋值给委托x，从而达到a方法调用委托x(b方法)。

    从这两种实现方式来说，第二种方式更加的灵活，因为没有将b方法直接写死在a方法里，所以，之后的一些变动，我们不需要修改BLL层A类a方法里的代码了(如果里面的逻辑很复杂，修改时非常危险和麻烦的)，只需要添加一些类一些方法就可以了，直接在U层修改(变化必然会修改，这个无法改变，但是，怎么变动会更加简单很重要)，这样会使我们工作非常的简单。这个就是委托的一个好处。

 

匿名函数

    匿名函数就是没有名称的函数，应用的场景就是，不需要函数重用，即：这个函数就用一次。举个例子说，U层使用A类的a方法时，直接给a方法传递一个匿名函数(a方法参数的定义时，需要使用委托)，至于为什么给a方法传递一个匿名函数，因为a方法里需要调用这个匿名方法，需要用这些逻辑运算，而这些逻辑运算只需要用一次，所以，传递一个匿名方法，这样就不用多此一举的再创建一个类，类里面在写上方法(刚刚的匿名方法)，因为这样创建完全没有必要(就使用这么一次)，如果这样创建一个多余的类的话，对于U层调用时，不方便代码的阅读，而是结构也是不易理解的。

Lambda表达式

    Lambda表达式就是一个升级版的匿名函数，它的好处使代码变得阅读变得更加的容易，代码变得也更加的紧凑。使代码变得更加的紧凑是匿名函数解决的一个问题，Lambda表达式，再次基础上解决了匿名函数的不便阅读问题。

 

实例

    从Lambda表达式的发展历史上，我们解释了委托，匿名函数，接下了，我们就进行相应的Demo演示

 委托和普通函数的比较

<span style="font-size:18px;">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace function1
{
    public class class1
    {
        public string GetName1() {
            return "直接写死的方法";
        }

        public string GetName2() {
            return "通过委托实现";
        }
    }
}

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

namespace function1
{
    //普通委托
    public delegate string MyDelegateClass();   
}

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

namespace function1
{
    public class class3
    {         
        public string GetName(MyDelegateClass myEnTrustFunction) { 
            return myEnTrustFunction();
        }

        public string GetName() {
            return new class1().GetName1();
        }
    }
}</span>

委托函数和委托匿名函数的比较

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

namespace function2
{
    public class class1
    {
        public string GetName1(MyDelegateClass myFunction) {
            return myFunction();
        }
    }
}

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

namespace function2
{
    //普通委托
    public delegate string MyDelegateClass();  
}

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

namespace function2
{
    public class class3
    {
        public string GetName() {
            return "委托函数";
        }
    }
}

委托匿名函数和委托Lambda表达式的比较

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

namespace function3
{
    //普通委托
    public delegate string MyDelegateClass();  
}

<span style="font-family: 宋体;">using System;</span>

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

namespace function3
{
    public class Class2
    {
        public string GetName(MyDelegateClass myFunction){
            return myFunction();
        }
    }
}

客户端代码

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

namespace 学习.Lambda表达式
{
    class Program
    {
        static void Main(string[] args)
        {
            #region 委托和普通函数的比较
            //function1.class3 fun1 = new function1.class3();
            //Console.WriteLine(fun1.GetName());
            //Console.WriteLine(fun1.GetName(new function1.class1().GetName2));
            #endregion

            #region 委托函数和委托匿名函数的比较
            //function2.class1 fClass1 = new function2.class1();
            //Console.WriteLine(fClass1.GetName1(new function2.class3().GetName));
            //Console.WriteLine(fClass1.GetName1(delegate() { return "匿名函数"; }));
            #endregion

            #region 委托匿名函数和委托lambda表达式的比较
            function3.Class2 class2 = new function3.Class2();

            Console.WriteLine(class2.GetName(delegate() { return "匿名函数"; }));
            class2.GetName(() => { return "Lambda表达式"; });
            #endregion
            
            Console.Read();
        }
    }
}

总结

    委托使代码变得更加的灵活，基类代码不再是死板的，避免了修改逻辑比较复杂的代码；匿名函数解决了为仅仅使用一次的方法的创建的复杂性，使代码变得更加的紧凑；Lambda表达式，具有了匿名函数的优点，同时解决了匿名函数不便阅读的问题。