C# 新委托使用方法 Lambda表达式，运算符 =>

C# 新委托使用方法 Lambda表达式，运算符 =>

下面以代码为例说明：

代码片段一

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

namespace Project1
{
    class Program
    {
        // 定义一个无参，返回类型为 int 的委托
        private delegate int Handler();

        // 定义一个参数为int，返回类型为int的委托
        private delegate int HandlerT(int n);

        // 定义两个参数为int, 返回类型为 int 的委托
        private delegate int HandlerTT(int m, int n);

        private static void AsDelegate()
        {
            //使用 Lambda 表达式创建委托类型的匿名函数
            //无参数的匿名函数
            // () => 10  意思是代指一个无参的方法，该方法返回 10
            Handler handler = () => 10;
            int number = handler();

            Console.WriteLine("number   : " + number);  // number   : 10

            // 下面 参数中的 value 的使用范围仅包含在其后的语句 { int m = 10; int n = 5; return value + m + n; };中
            // 超出 大括号范围将 value 作为垃圾回收
            HandlerT h = (value) => { int m = 10; int n = 5; return value + m + n; };
            number = h(2);
            Console.WriteLine("number    : " + number); // number   : 17

            //使用 Lambda 表达式创建委托类型的匿名函数
            //一个参数的匿名函数
            // r => r * r 代指一个参数的方法，参数为 r，该方法返回 r * r 
            HandlerT handlerT = r => r * r;
            number = handlerT(5);

            Console.WriteLine("number   : " + number);  // number   : 25

            //上面用法类似于下面, 匿名函数
            handlerT = delegate (int n) { return n * n; };
            number = handlerT(5);
            Console.WriteLine("number2  : " + number); // number2   : 25

            // 使用 Lambda 表达式创建委托类型的匿名函数
            // 一个以上的匿名函数必须使用小括号将所有参数括起来
            // (a, b) => a * b; 代指两个参数的方法，参数为 a, b, 该方法返回 a * b
            HandlerTT handlerTT = (a, b) => a * b;

            number = handlerTT(5, 6);
            Console.WriteLine("number3  : " + number); // number3   : 30
        }

        // Lambda 表达式作为 委托参数传入函数内
        private static void AsResult(Handler handler, HandlerT handlerT, int value)
        {
            // 调用 handler() 计算结果赋值为 m
            int m = handler();                    
            Console.WriteLine("m      : " + m);    // m     : 10

            // 调用 handlerT(), 将 value 作为参数，计算结果赋值给 n
            int n = handlerT(value);              
            Console.WriteLine("n      : " + n);    // n     : 25
        }

        static void Main(string[] args)
        {
            AsDelegate();

            int result = 0;
            // Lambda 表达式作为参数传入函数
            // () => 10 代指 无参方法，直接返回 10
            // r => result = r * r 代指 一个参数的方法
            // 参数为 r, 返回值为 r * r, 且将 r * r 的结果赋值给 result
            AsResult(() => 10, r => result = r * r, 5);

            Console.WriteLine("result    : " + result);    // result    : 25

            Console.ReadLine();
        }
    }
}

代码片段二

using UnityEngine;
using System.Collections;

public class Test : MonoBehaviour {
    void Update () {

        if (Input.GetKeyDown(KeyCode.A))
        {
            // 调用使用  () =>  方法
            // () => 10  意思是代指一个无参的方法，该方法返回 10
            int number = TFunction(() => 10, () => 5, () => 8);
            Debug.Log("n1 = " + number);      // 打印结果： n3 = 23

            // 调用使用  () =>  方法
            // () => 10 + 2  意思是 代指一个无参的方法， 该方法返回  10 + 2 即  12
            number = TFunction(() => 10 + 2, () => 5 + 2, () => 8 + 2);
            Debug.Log("n2 = " + number);      // 打印结果： n3 = 23


            // 调用使用  () =>  方法， 使用 r => a = r 形式
            // () => 3 + 6 意思是代指一个无参的方法， 该方法返回 3 + 6 即  9
            // r => a = r  意思是代指一个参数的方法， r 代指该方法的 参数
            // a = r      执行该代码后  将 r 的值赋值给 a  
            int a = 0;
            int V3 = TFunc( () => 3 + 6, r => a = r, 10);
            Debug.Log("V3  = " + V3);        // 打印结果： V3  = 19
            Debug.Log("a   = " + a);         // 打印结果： a   = 10
        }
    }

    //定义无参的委托
    public delegate int FunDelegate();

    private int TFunction(FunDelegate fun1, FunDelegate fun2, FunDelegate fun3)
    {
        return fun1() + fun2() + fun3();
    }

    // 定义无参的委托
    public delegate int FunDel();
    // 定义一个整形参数的 委托
    public delegate int FFF(int N);

    private int TFunc(FunDel fun1, FFF fun2, int num)
    {
        return fun1() + fun2( num);
    }
}