Lambda for Dummies...任何人，任何人？我认为不是

Question

在我寻求理解看起来非常奇怪的 ' => ' 运算符，我找到了一个很好的 从哪里开始，作者非常简洁明了：

参数=>表达

有没有人有任何关于理解 lambda 基础知识的提示，以便更容易“破译”更复杂的 lambda 语句？

例如：如果我得到类似的东西（来自我在这里收到的答案):

filenames.SelectMany(f => 
        Assembly.LoadFrom(f).GetCustomAttributes(typeof(PluginClassAttribute), true)
        .Cast<PluginClassAttribute>()
        .Select(a => a.PluginType)
).ToList();

我怎样才能把它分解成更简单的部分？

---

更新：想展示我的第一个 lambda 表达式。不要笑我，但我没有复制别人的例子就做到了……而且第一次就成功了：

public ModuleData[] GetStartModules( )
{ return modules.FindAll(start => start.IsBatch == true).ToArray(); }

Answer 1

让我们剖析您的代码示例：

filenames.SelectMany(f => 
        Assembly.LoadFrom(f).GetCustomAttributes(typeof(PluginClassAttribute), true)
        .Cast<PluginClassAttribute>()
        .Select(a => a.PluginType)
).ToList();

因此，我们从一个名为 filenames 的 string[] 开始。我们对数组调用 SelectMany 扩展方法，然后对结果调用 ToList：

filenames.SelectMany(
   ...
).ToList();

在本例中，SelectMany 采用委托作为参数委托必须采用 string 类型的一个参数作为输入，并返回一个 IEnumerable（其中推断出 T 的类型） 。这就是 lambda 登场的地方：

filenames.SelectMany(f => 
        Assembly.LoadFrom(f).GetCustomAttributes(typeof(PluginClassAttribute), true)
).ToList()

这里将发生的是，对于 filenames 数组中的每个元素，都会调用委托。 f 是输入参数，=> 右侧的内容是委托引用的方法体。在这种情况下，将针对数组中的文件名调用 Assembly.LoadFrom，并使用 f 参数将文件名传递到 LoadFrom 方法中。在返回的 AssemblyInstance 上，将调用 GetCustomAttributes(typeof(PluginClassAttribute), true)，它返回 Attribute 实例的数组。所以编译器无法推断出前面提到的T的类型是Assembly。

在返回的 IEnumerable 上，将调用 Cast()，返回 IEnumerable。

现在我们有了一个 IEnumerable，我们对其调用 Select。 Select 方法与 SelectMany 类似，但返回类型 T 的单个实例（由编译器推断），而不是 >IEnumerable。设置是相同的；对于 IEnumerable 中的每个元素，它将调用定义的委托，将当前元素值传递给其中：

.Select(a => a.PluginType)

同样，a 是输入参数，a .PluginType 是方法主体。因此，对于列表中的每个 PluginClassAttribute 实例，它将返回 PluginType 属性的值（我假设该属性的类型为 Type）。

执行摘要
如果我们将这些碎片粘合在一起：

// process all strings in the filenames array
filenames.SelectMany(f => 
        // get all Attributes of the type PluginClassAttribute from the assembly
        // with the given file name
        Assembly.LoadFrom(f).GetCustomAttributes(typeof(PluginClassAttribute), true)
        // cast the returned instances to PluginClassAttribute
        .Cast<PluginClassAttribute>()
        // return the PluginType property from each PluginClassAttribute instance
        .Select(a => a.PluginType)
).ToList();

---

Lambda 与委托
让我们通过比较 lambda 和委托来结束这一点。采取以下列表：

List<string> strings = new List<string> { "one", "two", "three" };

假设我们要过滤掉以字母“t”开头的那些：

var result = strings.Where(s => s.StartsWith("t"));

这是最常见的方法；使用 lambda 表达式进行设置。但还有其他选择：

Func<string,bool> func = delegate(string s) { return s.StartsWith("t");};
result = strings.Where(func);

这本质上是同一件事：首先我们创建一个 Func 类型的委托（这意味着它需要一个 string 作为输入参数，并返回一个 bool）。然后我们将该委托作为参数传递给 Where 方法。这就是编译器在第一个示例中在幕后为我们所做的事情 (strings.Where(s => s.StartsWith("t"));)。

第三种选择是简单地将委托传递给非匿名方法：

private bool StringsStartingWithT(string s)
{
    return s.StartsWith("t");
}

// somewhere else in the code:
result = strings.Where(StringsStartingWithT);

因此，在我们在这里看到的情况下，lambda 表达式是定义委托的一种相当紧凑的方式，通常引用匿名方法。

如果您有精力读完这里，那么，谢谢您的宝贵时间:)

Answer 2

因此，从可怕的定义开始 - lambda 是定义匿名方法的另一种方式。 （我相信从 C# 2.0 开始）有一种构造匿名方法的方法 - 然而这种语法非常......不方便。

那么什么是匿名方法呢？这是一种定义内联方法的方法，没有名称 - 因此是匿名的。如果您有一个接受委托的方法，这非常有用，因为您可以将此 lambda 表达式/匿名方法作为参数传递（假设类型匹配）。以 IEnumerable.Select 为例，它的定义如下：

IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector);

如果您通常在 List 上使用此方法并选择每个元素两次（即与其自身连接）：

string MyConcat(string str){
    return str + str;
}

...

void myMethod(){
    IEnumerable<string> result = someIEnumerable.Select(MyConcat);
}

这是一种非常不方便的方法，尤其是如果您希望执行许多这样的操作 - 通常这些类型的方法您只使用一次。您显示的定义（参数 => 表达式）非常简洁并且恰到好处。 lambda 的有趣之处在于，您不需要表达参数的类型 - 只要可以从表达式中推断出它们即可。 IE。在 Select 的例子中 - 我们知道第一个参数必须是 TSource 类型 - 因为方法的定义是这样规定的。更进一步 - 如果我们像 foo.Select(...) 一样调用该方法，那么表达式的返回值将定义 TResult。

一件有趣的事情是，对于单语句 lambda 来说，不需要 return 关键字 - lambda 将返回一个表达式计算结果的任何内容。但是，如果您使用块（包含在“{”和“}”中），则必须像往常一样包含 return 关键字。

如果愿意的话，定义参数的类型仍然是 100% 合法的。有了这些新知识，让我们尝试重写前面的示例：

void myMethod(){
    IEnumerable<string> result = someIEnumerable.Select(s => s + s);
}

或者，使用明确的参数声明

void myMethod(){
    IEnumerable<string> result = someIEnumerable.Select((string s) => s + s);
}

C# 中 lambda 的另一个有趣功能是它们用于构造 表达式树。虽然这可能不是“初学者”材料 - 但简而言之，表达式树包含有关 lambda 的所有元数据，而不是可执行代码。

Answer 3

好吧，您可以将 lambda 视为编写只想使用一次的方法的快速方法。例如，以下方法

private int sum5(int n)
{
    return n + 5;
}

等效于 lambda：(n) => n + 5 。除了您可以在类中的任何位置调用该方法，并且 lambda 仅存在于它声明的范围内（您还可以将 lambda 存储在 Action 和 Func 对象中）

lambda 可以为您做的其他事情是捕获范围、构建闭包。例如，如果您有这样的内容：

...methodbody
int acc = 5;
Func<int> addAcc = (n) => n + acc;

您拥有的函数像以前一样接受参数，但添加的金额取自变量的值。即使在定义 acc 的范围结束后，lambda 仍然可以存在。

您可以使用 lambda 构建非常简洁的东西，但您必须小心，因为有时您会因为这样的技巧而失去可读性。

Answer 4

正如其他人所说，lambda 表达式是函数的一种表示法。它将表达式右侧的自由变量绑定到左侧的参数。

a => a + 1

创建一个函数，将表达式 (a + 1) 中的自由变量 a 绑定到函数的第一个参数并返回该函数。

Lambda 非常有用的一种情况是当您使用它们来处理列表结构时。 System.Linq.Enumerable 类提供了许多有用的函数，允许您使用 Lambda 表达式和实现 IEnumerable 的对象。例如，Enumerable.Where 可用于过滤列表：

List<string> fruits = new List<string> { 
        "apple", "passionfruit", "banana", "mango", 
        "orange", "blueberry", "grape", "strawberry" };

IEnumerable<string> shortFruits = fruits.Where(fruit => fruit.Length < 6);

foreach (string fruit in shortFruits) {
    Console.WriteLine(fruit);
}

输出将为“苹果、芒果、葡萄”。

尝试理解这里发生了什么：表达“fruit =>”水果长度< 6 创建一个函数，如果参数的 Length 属性小于 6，则返回 true。Enumerable.Where

循环遍历 List 并创建一个新 List，其中仅包含所提供的函数返回 true 的元素。这使您无需编写迭代列表、检查每个元素的谓词并执行某些操作的代码。

Answer 5

针对那些熟悉编码但不熟悉 lambda 的开发人员提供了一个很好的简单解释

TekPub 上的这个简单视频TekPub - 概念：#2 Lambdas

您显然在这里有很多反馈，但这是另一个很好的来源和一个简单的解释。

Answer 6

我知道这有点老了，但我来这里是为了理解所有这些 lambda 的东西。
当我完成所有答案和评论时，我对 lambda 有了更好的理解，并认为我应该添加这个简单的答案（从学习者的角度到学习者）：

不要混淆 a =>; a + 1 意思是a加1并将结果返回给a。 （这很可能会让初学者感到困惑。
相反，应该这样看：a 是函数（未命名函数）的输入参数，a + 1 是函数中的语句（“动态”构造的未命名函数）。

希望这有帮助:)

Answer 7

Lambda 演算在许多编程语言中都很常见。在某些语言中它们也称为匿名函数。尽管不同的语言对 lambda 的语法不同，但原理是相同的，并且它们的各个部分通常是相同的。

也许最著名的就是 Javascript 的匿名函数。

lol = function() {laugh()}
# is equivalent to
function lol() {laugh()}

有什么区别？好吧，有时您不想经历创建一个函数的麻烦，只是为了将它传递到某个地方一次，然后再也不会。

window.onload = function() {laugh()}
# is way easier than
function lol() {laugh()}
window.onload = lol

您可以查看维基百科文章以获取独立信息，或者您可以直接跳至编程中的 Lambda 在同一篇文章中。

Answer 8

这只是 C# 写下函数值的表示法。它不需要为函数命名，因此该值有时称为匿名函数。其他语言有其他符号，但它们总是包含参数列表和主体。

最初的符号由 Alonzo Church 为其1930 年代的 Lambda 演算 在表达式 λx.t 中使用希腊字符 lambda 来表示函数，因此得名。

Answer 9

我理解 lambda 基础知识的技巧有两个。

首先我建议学习函数式编程。在这方面，Haskell 是一种很好的入门语言。我正在使用的书是 Programming in Haskell格雷厄姆·赫顿著。这为 Haskell 提供了良好的基础，并包括 lambda 的解释。

从那里我认为你应该查看 Erik Meijer 关于函数式编程的讲座，因为他们给出了很好的还介绍了函数式编程，同样使用 Haskell，并跨入 C#。

一旦您掌握了所有内容，您就应该能够很好地理解 lambda 了。

Answer 10

CodeProject 最近有一篇很好的介绍性文章： C# 委托、匿名方法和 Lambda 表达式 – O My!