C# Lamda到底是什么？！

lamda作为匿名函数，现在已经能够出现子啊C#程序的任何可能位置，它可能作为参数为委托或其他函数复制，或者单独作为表达式，或者承担一些类似C++中内联函数的一些作用承担一些简单计算。熟练的使用Lamda表达式能够让减少代码的冗余，更快，更简洁实现功能。

lamda表达式可采用以下任何一种：

表达式lamda，表达式作为主题

表达式位于 => 运算符右侧的 lambda 表达式称为“表达式 lambda”。 表达式 lambda 会返回表达式的结果，并采用以下基本形式：

 (输入参数) => 表达式
 (input-parameter)=> expression

语句 lambda，语句块作为其主体

（输入参数）=>{语句列表}
(input-parameters) => {  }

任何lamda都可以转换为委托。 如果 lambda 表达式不返回值，则可以将其转换为 Action 委托类型之一；否则，可将其转换为 Func 委托类型之一。

Action和Func两者最基本的区别是:前者适合那些需要带返回值的委托，后者适合那些不带返回值的委托。 Func 所引用的方法接收一个或者多个参数并带有一个返回值，Action所引用的方法接收一个或者多个参数并且没有返回值，换句话说，你的委托所引用的方法没有返回值，这时候适合用 Action。

ex：

private void Actionlamda() {
    Action<string> print = name => {
        Debug.Log(name);
    };

    print("Hello World");
    // Hello World
}

private void Funclamda() {
    Func<int, int, int> func = (lhs, rhs) => {
        return lhs + rhs;
    };
    Debug.Log(func(1,1));
    // 2
}

lamda表达式的输入参数

使用空括号指定零个输入参数：

Action line = () => Console.WriteLine();

只有一个参数时可以省略括号

Func<double, double> cube = x => x * x * x;

当具有两个或两个以上的参数时，中间用逗号加以分割

Func<int, int, bool> testForEquality = (x, y) => x == y;

当编译器不能明确参数类型的时候可以显示指定参数类型

Func<int, string, bool> isTooLong = (int x, string s) => s.Length > x;

输入的参数必须全部是显示或者隐式的，否则会产生错误

从C#9.0开始，可以使用弃元指定lamda表达式中不使用的参数

Func constant = (_, _) => 42;

为了向后兼容，如果只有一个输入参数命名为 ，则在 lambda 表达式中， 将被视为该参数的名称。

所以可以是下面的情况：

Func<int, int> func = (_) => _+19;

从C# 12.0开始lamda表达式参数支持默认值

var IncrementBy = (int source, int increment = 1) => source + increment;

Console.WriteLine(IncrementBy(5)); // 6
Console.WriteLine(IncrementBy(5, 2)); // 7

支持params 修饰参数

var sum = (params int[] values) =>
{
    int sum = 0;
    foreach (var value in values) 
        sum += value;
    
    return sum;
};

var empty = sum();
Console.WriteLine(empty); // 0

var sequence = new[] { 1, 2, 3, 4, 5 };
var total = sum(sequence);
Console.WriteLine(total); // 15

params 是可变参数，用于在不清楚参数数目是使用，被修饰的参数必须是数组。
** EX:**

namespace ConsoleApp1
{
    class Program
    {
        static void Main()
        {
            UseParams(1, 2, 3); //既可以用任意多个int
 
            int[] myarray = new int[3] { 10, 11, 12 };
            UseParams(myarray); //也可以是int一维数组  
 
            UseParams2(1, 'a', new object() );
        }
 
        public static void UseParams(params int[] list)
        {
            for (int i = 0; i < list.Length; i++)
            {
                Console.WriteLine(list[i]);
            }
            Console.WriteLine();
        }
 
        public static void UseParams2(params object[] list)
        {
            for (int i = 0; i < list.Length; i++)
            {
                Console.WriteLine(list[i]);
            }
            Console.WriteLine();
        }
    }
}

lamda表达式和元组

private void LamdaText() {
    Func<(int, int), (int, int)> func = _ => (_.Item1*2, _.Item2 * 2) ;
    var num = (1,2);
    Debug.Log(func(num));
    // (2.4)
}

除了使用C# 内置的Item1，Item2在元组中也可以使用参数名参与运算

private void LamdaText() {
    Func<(int n1, int n2), (int, int)> func = _ => (_.n1 * 2, _.n2 * 2);
    var num = (1, 2);
    Debug.Log(func(num));
    // (2.4)
}

含标椎查询语句的Lamda

Lamda可以结合Linq查询语句，快速得到想要的结果

public override List<NodeBase> CacheNeighbors()
{
    return Neighbor = GridManager.Instance.Tiles.Where(t => Coords.GetDistance(t.Value.Coords) == 1).Select(t => t.Value).ToList();
}

Count 标准查询运算符：

int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
int oddNumbers = numbers.Count(n => n % 2 == 1);
Console.WriteLine($"There are {oddNumbers} odd numbers in {string.Join(" ", numbers)}");

其中包含 numbers 数组中位于 9 之前的所有元素，因为这是序列中第一个不符合条件的数字：

int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
var firstNumbersLessThanSix = numbers.TakeWhile(n => n < 6);
Console.WriteLine(string.Join(" ", firstNumbersLessThanSix));
// Output:
// 5 4 1 3

下示例通过将输入参数括在括号中来指定多个输入参数。 此方法返回 numbers 数组中的所有元素，直至发现值小于其在数组中的序号位置的数字为止：

int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
var firstSmallNumbers = numbers.TakeWhile((n, index) => n >= index);
Console.WriteLine(string.Join(" ", firstSmallNumbers));
// Output:
// 5 4