这是一种将小操作放在非常接近使用位置的地方的方法(与在接近使用点的地方声明变量没有什么不同)。这将使您的代码更具可读性。通过匿名化表达式，如果在其他地方使用了该函数并对其进行了修改以“增强”它，那么其他人就很难破坏您的客户端代码。

同样，为什么需要使用foreach?你可以用一个简单的for循环来完成foreach中的所有事情，或者直接使用IEnumerable。答案:你不需要它，但它使你的代码更可读。

创新在于类型的安全性和透明度。虽然您没有声明lambda表达式的类型，但它们是推断出来的，并且可以由代码搜索、静态分析、重构工具和运行时反射使用。

例如，在您使用SQL之前，可能会受到SQL注入攻击，因为黑客在通常需要数字的地方传递了一个字符串。现在您将使用LINQ lambda表达式，这是受保护的。

在纯委托上构建LINQ API是不可能的，因为它需要在计算表达式树之前将它们组合在一起。

2016年，大多数流行语言都支持lambda表达式，c#是主流命令式语言中这一演变的先驱之一。

很多时候，您只在一个地方使用功能，所以创建方法只会使类变得混乱。

例如，Lambda表达式使任务简单得多

var numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

var oddNumbers = numbers.Where(x => x % 2 != 0);
var sumOfEven = numbers.Where(x => x % 2 == 0).Sum();

在上面的代码中，因为我们使用了lambda，所以我们在一行代码中得到奇数和偶数的和。

如果没有lambda，我们将不得不使用if/else或for循环。

因此，使用lambda来简化c#中的代码是很好的。

一些关于它的文章:

https://qawithexperts.com/article/c-sharp/lambda-expression-in-c-with-examples/470

https://exceptionnotfound.net/csharp-in-simple-terms-18-expressions-lambdas-and-delegates

http://dontcodetired.com/blog/post/Whats-New-in-C-10-Easier-Lambda-Expressions

这样可以避免在远离使用方法的地方定义只在特定位置使用一次的方法。好的用途是作为泛型算法(如排序)的比较器，然后您可以定义一个自定义排序函数，在该函数中调用排序，而不是进一步迫使您查看其他地方以查看您正在排序的对象。

这并不是真正的创新。LISP拥有lambda函数已经有30年或更长时间了。

Microsoft has given us a cleaner, more convenient way of creating anonymous delegates called Lambda expressions. However, there is not a lot of attention being paid to the expressions portion of this statement. Microsoft released a entire namespace, System.Linq.Expressions, which contains classes to create expression trees based on lambda expressions. Expression trees are made up of objects that represent logic. For example, x = y + z is an expression that might be part of an expression tree in .Net. Consider the following (simple) example:

using System;
using System.Linq;
using System.Linq.Expressions;


namespace ExpressionTreeThingy
{
    class Program
    {
        static void Main(string[] args)
        {
            Expression<Func<int, int>> expr = (x) => x + 1; //this is not a delegate, but an object
            var del = expr.Compile(); //compiles the object to a CLR delegate, at runtime
            Console.WriteLine(del(5)); //we are just invoking a delegate at this point
            Console.ReadKey();
        }
    }
}

This example is trivial. And I am sure you are thinking, "This is useless as I could have directly created the delegate instead of creating an expression and compiling it at runtime". And you would be right. But this provides the foundation for expression trees. There are a number of expressions available in the Expressions namespaces, and you can build your own. I think you can see that this might be useful when you don't know exactly what the algorithm should be at design or compile time. I saw an example somewhere for using this to write a scientific calculator. You could also use it for Bayesian systems, or for genetic programming (AI). A few times in my career I have had to write Excel-like functionality that allowed users to enter simple expressions (addition, subtrations, etc) to operate on available data. In pre-.Net 3.5 I have had to resort to some scripting language external to C#, or had to use the code-emitting functionality in reflection to create .Net code on the fly. Now I would use expression trees.