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

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

The biggest benefit of lambda expressions and anonymous functions is the fact that they allow the client (programmer) of a library/framework to inject functionality by means of code in the given library/framework ( as it is the LINQ, ASP.NET Core and many others ) in a way that the regular methods cannot. However, their strength is not obvious for a single application programmer but to the one that creates libraries that will be later used by others who will want to configure the behaviour of the library code or the one that uses libraries. So the context of effectively using a lambda expression is the usage/creation of a library/framework.

此外，由于它们描述的是一次性使用的代码，所以它们不必是类的成员，这样会导致代码更加复杂。想象一下，每当我们想要配置类对象的操作时，都必须声明一个焦点不明确的类。

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

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

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

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

Lambda表达式对于匿名委托来说是一种更简单的语法，可以在任何可以使用匿名委托的地方使用。然而，反过来就不对了;lambda表达式可以转换为表达式树，这允许很多魔术，如LINQ到SQL。

下面是一个使用匿名委托的LINQ to Objects表达式的例子，然后是lambda表达式，以显示它们是多么容易。

// anonymous delegate
var evens = Enumerable
                .Range(1, 100)
                .Where(delegate(int x) { return (x % 2) == 0; })
                .ToList();

// lambda expression
var evens = Enumerable
                .Range(1, 100)
                .Where(x => (x % 2) == 0)
                .ToList();

Lambda表达式和匿名委托相对于编写单独的函数有一个优势:它们实现了闭包，允许您将局部状态传递给函数，而无需向函数添加参数或创建一次性对象。

表达式树是c# 3.0的一个非常强大的新特性，它允许API查看表达式的结构，而不仅仅是获取一个可以执行的方法的引用。API只需要将委托参数转换为Expression<T>参数，编译器就会从lambda而不是匿名委托生成表达式树:

void Example(Predicate<int> aDelegate);

被称为:

Example(x => x > 5);

就变成:

void Example(Expression<Predicate<int>> expressionTree);

后者将获得描述表达式x > 5的抽象语法树的表示。LINQ to SQL依赖于此行为，能够将c#表达式转换为服务器端过滤/排序等所需的SQL表达式。

您还可以在编写作用于方法的泛型代码时使用lambda表达式。

例如:计算方法调用所花费的时间的泛型函数。(即这里的动作)

public static long Measure(Action action)
{
    Stopwatch sw = new Stopwatch();
    sw.Start();
    action();
    sw.Stop();
    return sw.ElapsedMilliseconds;
}

你可以使用lambda表达式调用上述方法，如下所示，

var timeTaken = Measure(() => yourMethod(param));

表达式允许您从方法和out参数中获取返回值

var timeTaken = Measure(() => returnValue = yourMethod(param, out outParam));

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.