委托和lambda

委托基础用法

    delegate void D1();
    delegate int D2(int a, int b);

    class Program
    {
        static void Main(string[] args)
        {
            //委托基础
            {
                D1 d1 = F1;
                d1();

                D2 d2 = Add;
                Console.WriteLine(d2(3, 5));


                Action a = F1;
                a();

                Func<int, int, int> func = Add;
                Console.WriteLine(func(1, 2));

                Func<int, int, string> func1 = Add1;
                Console.WriteLine(func1(2, 2));
            }

            Console.Read();
        }

        static void F1()
        {
            Console.WriteLine("我是F1");
        }

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

        static string Add1(int a, int b)
        {
            return $"和为{a + b}";
        }

    }

执行结果：

delegate声明委托

Action声明没有返回值的委托

Func声明带有返回值的委托

匿名方法

   static void Main(string[] args)
        {

            //匿名委托
            //委托变量不仅可以指向普通方法,还可以指向匿名方法
            {
                //无参无返回值的匿名方法
                Action a1 = delegate ()
                {
                    Console.WriteLine("我是张三");
                };
                a1();

                //有参无返回值的匿名方法
                Action<string, int> a2 = delegate (string a, int b)
                {
                    Console.WriteLine($"a={a},b={b}");
                };
                a2("张三", 18);

                //有参有返回值的匿名方法
                Func<int, int, int> f1 = delegate (int a, int b)
                {
                    return a + b;
                };
                Console.WriteLine(f1(1, 1));
            }

            Console.Read();
        }

执行结果：

 委托变量不仅可以指向普通方法，还可以指向匿名方法。

lambda表达式

static void Main(string[] args)
        {
            //lambda
            //匿名方法可以写成lambda表达式
            {
                //可以省略参数数据类型,以为编译能根据委托类型推断出参数的类型,用=>引出方法体
                Func<int, int, string> f1 = (i, j) =>
                {
                    return $"{i}+{j}={i + j}";
                };
                Console.WriteLine(f1(1, 6));


                //如果委托没有返回值,且方法体只有一行代码,可以省略{}
                Action<int, string> a1 = (age, name) => Console.WriteLine($"年龄:{age},姓名:{name}");
                a1(20, "李四");


                //如果方法体只有一行代码且有返回值,可以省略{}和return
                Func<int, int, int> f2 = (i, j) => i + j;
                Console.WriteLine(f2(5, 5));

                //如果只有一个参数,参数的()可以省略
                Action<string> a2 = s => Console.WriteLine(s);
                a2("测试语句");

                Func<int, bool> f3 = i => i > 5;
                Console.WriteLine(f3(4));
            }

            Console.Read();
        }

执行结果：

 

匿名方法可以写成lambda表达式。