C#中的匿名方法、Lambda表达式、泛型委托

复制代码

public class LambdaDemo
{

    public void Test1()
    {
        //委托变量和方法关联（以前方法）
        CalculatorDelegate cal1 = Add;

        //委托变量可以直接关联一个"匿名方法"
        CalculatorDelegate cal2 = delegate (int a, int b)
          {
              return a + b;
          };

        //将命名方法用Lambda表达式简化（goes to）
        CalculatorDelegate cal3 = (int a, int b) => { return a + b; };

        //测试
        Console.WriteLine("通过匿名方法计算cal2：" + cal2(10, 20));
        Console.WriteLine("通Lambda表达式计算cal3：" + cal3(10, 20));

        //进一步简化Lambda表达式的写法（只适合只有一行代码的情况）
        CalculatorDelegate cal4 = (int a, int b) => a + b;
        CalculatorDelegate cal5 = (a, b) => a + b; //根据委托定义自动推断

        Console.WriteLine("通Lambda表达式计算cal4：" + cal4(10, 20));
        Console.WriteLine("通Lambda表达式计算cal5：" + cal5(10, 20));
        //Console.WriteLine("通Lambda表达式计算cal5：" + cal5(10.6, 20.7));//这个是错误的

        SayHelloDelegate sayHello = delegate ()
          {
              return "我是常老师，感谢大家学习C#上位机开发技术！";
          };

        SayHelloDelegate sayHello2 = () => "我是常老师，感谢大家学习C#上位机开发技术！";

        Console.WriteLine(sayHello());
        Console.WriteLine(sayHello2());
    }

    private int Add(int a, int b)
    {
        return a + b;
    }
}

//定义两个参数的委托
public delegate int CalculatorDelegate(int a, int b);

//定义无参数的委托
public delegate string SayHelloDelegate();

委托的扩展用途：匿名方法、Lambda表达式、和泛型结合、多线程使用...

1、匿名方法和Lambda表达式

1、匿名方法概念：一个方法没有具体的名称，而只有关键字delegate、方法参数、方法体。

2、匿名方法好处：将具体方法和委托直接关联在一起，如果委托只需要一个方法的时候，匿名方法肯定是显得简单。

3、Lambda表达式：在C#3.0。使用这种表达式可以更简练的编写代码块。

【1】在Lambda表达式中，参数类型可以是明确类型，也可以是推断类型，就是写参数类型。

【2】如果是推断类型，编译器根据上下文自动推断。

【3】运算符=>读作goes to，运算符左边括号输入参数（如果有），右边是表达式或语句块。

【4】表达式两种方式

（input args）=>表达式可以不写return

（input args）=>{语句1；语句2；语句3....；}

【5】Lambda表达式和匿名方法比较

第二、Lambda表达式允许不指名参数类型，但是匿名方法必须明确类型。

第三、Lambda表达式允许单一表达式或多条语句组成，而匿名方法不允许单一表达式，必须写方法体里面。

2、自定义泛型委托

1、为什么要使用泛型委托？

普通委托在数据类型的限定上非常严格，有时候我们的需求是变化的，可能就适应不了。

2、泛型委托定义：本质上和泛型方法是非常相似的，泛型委托关联的时候，可以是具体方法、匿名方法，也可以是Lambda表达式。

cs 复制代码

namespace thinger.DelegateLambda
{
     //定义泛型委托
    public delegate T MyGenericDelegate<T>(T param1, T param2);
    
    public class GenericDelegate
    {
        public void Test()
        {
            //定义泛型委托变量
            MyGenericDelegate<int> myDelegate1 = Add;
            MyGenericDelegate<double> myDelegate2 = Sub;

            Console.WriteLine("自定义泛型委托1:10+20="+myDelegate1(10,20));
            Console.WriteLine("自定义泛型委托2:10.5-0.8=" + myDelegate2(10.5, 0.8));

            //使用泛型委托：结合匿名方法
            MyGenericDelegate<int> myDelegate3 = delegate (int a, int b) { return a + b; };
            MyGenericDelegate<double > myDelegate4 = delegate (double a, double b) { return a - b; };

            Console.WriteLine("自定义泛型委托3:10+20=" + myDelegate3(10, 20));
            Console.WriteLine("自定义泛型委托4:10.5-0.8=" + myDelegate4(10.5, 0.8));

            //使用泛型委托：结合Lambda表达式
            MyGenericDelegate<int> myDelegate5 = (a, b) => a + b;
            MyGenericDelegate<double> myDelegate6 = (a, b) => a - b;

            Console.WriteLine("自定义泛型委托5:10+20=" + myDelegate5(10, 20));
            Console.WriteLine("自定义泛型委托6:10.5-0.8=" + myDelegate6(10.5, 0.8));
        }

        //定义方法
        public int Add(int a, int b)
        {
            return a + b;
        }
        public double Sub(double a, double b)
        {
            return a - b;
        }
    }

3、系统的泛型委托

cs 复制代码

namespace thinger.ActionAndFunc
{
    public class ActionAndFuncBase
    {

        /// <summary>
        /// 没有参数的系统泛型委托
        /// </summary>
        public void Test()
        {
            Action action = () => Console.WriteLine("大家好，我是常老师！");
            Action<string> action1 = (name) => Console.WriteLine($"我们正在和{name}学习上位机开发技术！");
            Action<string, string> action2 = (name, course) => Console.WriteLine($"{name}  正在讲解 {course}");

            //调用
            action();
            action1("常老师");
            action2("常老师", "C#智能上位机开发高级编程技术");
        
        }
        /// <summary>
        /// 有参数的系统泛型委托
        /// </summary>
        public void Test1()
        {
            Func<int, int, double> myFunc1 = (a, b) => a + b;
            Func<int> myFunc2 = () =>
            {
                int a = 10;
                int b = 20;
                return a + b;
            };

            Console.WriteLine(myFunc1(10,20));
            Console.WriteLine(myFunc2());
        }
    }


}

NET平台早就考虑了这种简单的泛型委托，那就是平台已经定义好了，我们可以直接使用！

两种方式：一种是没有返回值的Action<args>，一种是有返回值Func<args>。

1、Action<args>，在多线程中用的非常多。

2、Func<args>。在扩展方法中用的非常多。

系统委托使用五步法变4步

2.声明方法原型

3.声明委托变量

4.委托变量关联/订阅方法

5使用委托变量