c#从委托到匿名方法到lambda表达式

委托

委托的概念：

    委托是用户自定义的类，它定义了方法的类型。储存的是一系列具有相同参数和返回类型方法的地址列表，调用委托时，此委托列表的所有方法都将被执行。

委托类型的定义：

委托类型必须在被用来创建变量以及类型对象之前声明。

委托类型的声明：

1.以delegate关键字开头。

2.返回类型+委托类型名+参数列表

delegate void MyDel(int a)

实例

class Program
    {
        //1、声明一个委托
        delegate int Mydel(int a, int b);
        static void Main(string[] args)
        {
            //3、定义委托类型变量
            Mydel mydel;
            //4、进行委托绑定
            mydel = new Mydel(add);
            //5、回调绑定的add方法
            int result = mydel(1, 1);
            Console.WriteLine(result);
        }

        //2、创建一个与委托关联的方法，两者具有相同的返回值类型和参数列表
        public static int add(int a,int b)
        {
            return a + b;
        }
        
    }

委托之Action< T >不带返回值的委托类型 
委托之Func< T >带返回值的委托类型

class Program
    {
        static void Main(string[] args)
        {
            //带返回值得委托类型
            Func f = add;
            Console.WriteLine("有返回的结果：{0}",f(1,1));

            //不带返回值的委托类型
            Action a = over;
            a(2, 2);
        }
        //定义一个有返回值的方法 
        public static int add(int a,int b)
        {
            return a + b;
        }
        //定义一个没有返回值的方法
        public static void over(double a, int b)
        {
            Console.WriteLine("结果为：" + (a + b));
        }
    }

 

 

 

匿名方法

class Program
    {
        //1、声明一个委托
        delegate int Mydel(int a, int b);
        static void Main(string[] args)
        {
            //2、定义一个匿名方法
            Mydel m = delegate (int a, int b)
            {
                return a + b;
            };
            //3、调用匿名方法
            int result = m(1, 1);
            Console.WriteLine(result);

            
        }   
    }

 

lambda表达式

class Program
    {
        //1、声明一个委托
        delegate int Mydel(int a, int b);
        static void Main(string[] args)
        {
            //2、Lambda表达式，大家发现没有，代码一个比一个简洁
            Mydel m = (a, b) => a + b;
            //3、调用方法
            int result = m(1, 1);
            Console.WriteLine(result);

            
        }   
    }

class Program
    {
        //定义一个委托
        public delegate int mydel(int a);
        static void Main(string[] args)
        {
            //调用当前委托
            int result = add(a => 10 + a, 10);
            Console.WriteLine(result);
            Console.WriteLine(add(a=>10-a,11));
        }

        //定义方法，参数为自定义委托和一个整型，返回值为自定义委托的返回值
        public static int add(mydel m,int a)
        {
            return m(a);
        }
    }

 

大家有没有发现，从委托到匿名方法再到lambda表达式，代码一个比一个简洁了，Lambda表达式的本质是“匿名方法”，即当编译我们的程序代码时，“编译器”会自动将“Lambda表达式”转换为“匿名方法”

Lambda表达式的语法结构：

参数列表=>语句块

其中的参数列表可以包含多个参数（与委托参数列表一致），0个和1个以上参数需要用括号括起来，例如：

()=>Console.WriteLine("表示有0个参数");

x=>Console.WriteLine("表示有一个参数为{0}",x);

(x,y)=>Console.WriteLine("表示有两个参数为：{0}、{1}",x,y);

 

语句块中有多条语句需要用大括号括起来，例如：

x=>{x++;return x;}