blocks|key|1547516|text|实际上，最简单的说法是lambda只是匿名函数的简写形式。委托可以做的不仅仅是匿名函数:事件、异步调用和多个方法链。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1547517|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Well, the really oversimplified version is that a lambda is just shorthand for an anonymous function. A delegate can do a lot more than just anonymous functions: things like events, asynchronous calls, and multiple method chains.

blocks|key|1547581|text|我对此没有太多的经验，但我会这样描述它:委托是任何函数的包装器，而lambda表达式本身就是一个匿名函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1547582|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I don't have a ton of experience with this, but the way I would describe it is that a delegate is a wrapper around any function, whereas a lambda expression is itself an anonymous function.

blocks|key|1547642|text|委托相当于函数指针/方法指针/回调(随意选择)，而lambda是非常简单的匿名函数。至少我是这么跟别人说的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1547643|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Delegates are equivalent to function pointers/method pointers/callbacks (take your pick), and lambdas are pretty much simplified anonymous functions. At least that's what I tell people.

blocks|key|1547689|text|lambdas仅仅是委托上的语法糖。编译器最终将lambda转换为委托。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1547690|这些都是一样的，我相信：|1547691|Delegate+delegate+=+x+=>+"hi!";
Delegate+delegate+=+delegate(object+x)+{+return+"hi";};|code-block|syntax|javascript|1547692|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

lambdas are simply syntactic sugar on a delegate. The compiler ends up converting lambdas into delegates.

These are the same, I believe:

<pre><code>Delegate delegate = x =&gt; "hi!";
Delegate delegate = delegate(object x) { return "hi";};
</code></pre>

blocks|key|1547865|text|委托是函数签名；类似于|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1547866|delegate+string+MyDelegate(int+param1);|code-block|syntax|javascript|1547867|委托不实现正文。|1547868|lambda是一个与委托签名匹配的函数调用。对于上面的委托，您可以使用以下任一；|1547869|(int+i)+=>+i.ToString();
(int+i)+=>+"ignored+i";
(int+i)+=>+"Step+"+%2B+i.ToString()+%2B+"+of+10";|1547870|不过，Delegate类型的名称很糟糕；创建Delegate类型的对象实际上会创建一个可以保存函数的变量--无论是lambda、静态方法还是类方法。|offset|length|style|CODE|1547871|entityMap^0|0|0|0|0|0|3|8|M|8|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|Z|8|@$O|10|P|11|Q|R]|$O|12|P|13|Q|R]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|T|$]]

A delegate is a function signature; something like 

<pre><code>delegate string MyDelegate(int param1);
</code></pre>

The delegate does not implement a body. 

The lambda is a function call that matches the signature of the delegate. For the above delegate, you might use any of;

<pre><code>(int i) =&gt; i.ToString();
(int i) =&gt; "ignored i";
(int i) =&gt; "Step " + i.ToString() + " of 10";
</code></pre>

The <code>Delegate</code> type is badly named, though; creating an object of type <code>Delegate</code> actually creates a variable which can hold functions -- be they lambdas, static methods, or class methods.

blocks|key|1547912|text|委托基本上只是一个函数指针。一个lambda可以变成一个委托，但它也可以变成一个LINQ表达式树。例如,|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1547913|Func<int,+int>+f+=+x+=>+x+%2B+1;
Expression<Func<int,+int>>+exprTree+=+x+=>+x+%2B+1;|code-block|syntax|javascript|1547914|第一行生成一个委托，而第二行生成一个表达式树。|1547915|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

A delegate is always just basically a function pointer. A lambda can turn into a delegate, but it can also turn into a LINQ expression tree. For instance,

<pre><code>Func&lt;int, int&gt; f = x =&gt; x + 1;
Expression&lt;Func&lt;int, int&gt;&gt; exprTree = x =&gt; x + 1;
</code></pre>

The first line produces a delegate, while the second produces an expression tree.

blocks|key|1762875|text|委托实际上只是函数的结构化类型。您可以使用命名类型和实现实现接口或抽象类的匿名类来做同样的事情，但当只需要一个函数时，这最终会产生大量代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1762876|Lambda来自20世纪30年代阿隆佐·丘奇的lambda演算思想。这是一种创建函数的匿名方式。它们对于组合函数特别有用。|1762877|因此，虽然有些人可能会说lambda是代表的语法糖，但我会说，代表是让人们轻松进入c#中的lambda的桥梁。|1762878|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Delegates are really just structural typing for functions. You could do the same thing with nominal typing and implementing an anonymous class that implements an interface or abstract class, but that ends up being a lot of code when only one function is needed.

Lambda comes from the idea of lambda calculus of Alonzo Church in the 1930s. It is an anonymous way of creating functions. They become especially useful for composing functions

So while some might say lambda is syntactic sugar for delegates, I would says delegates are a bridge for easing people into lambdas in c#.

blocks|key|1762926|text|Lambda是委托的简化版本。它们具有closure的一些属性，如匿名委托，但也允许您使用隐式类型。像这样的lambda：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1762927|something.Sort((x,+y)+=>+return+x.CompareTo(y));|code-block|syntax|javascript|1762928|比你对委托所做的要简洁得多：|1762929|something.Sort(sortMethod);
...

private+int+sortMethod(SomeType+one,+SomeType+two)
{
++++one.CompareTo(two)
}|1762930|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Closure_(computer_science)^0|J|7|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Lambdas are simplified versions of delegates. They have some of the the properties of a <a href="http://en.wikipedia.org/wiki/Closure_(computer_science)" rel="nofollow noreferrer">closure</a> like anonymous delegates, but also allow you to use implied typing. A lambda like this:

<pre><code>something.Sort((x, y) =&gt; return x.CompareTo(y));
</code></pre>

is a lot more concise than what you can do with a delegate:

<pre><code>something.Sort(sortMethod);
...

private int sortMethod(SomeType one, SomeType two)
{
 one.CompareTo(two)
}
</code></pre>

blocks|key|1762974|text|一个不同之处在于，匿名委托可以省略参数，而lambda必须与确切的签名匹配。给定：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1762975|public+delegate+string+TestDelegate(int+i);

public+void+Test(TestDelegate+d)
{}|code-block|syntax|javascript|1762976|您可以通过以下四种方式调用它(请注意，第二行有一个没有任何参数的匿名委托)：|1762977|Test(delegate(int+i)+{+return+String.Empty;+});
Test(delegate+{+return+String.Empty;+});
Test(i+=>+String.Empty);
Test(D);

private+string+D(int+i)
{
++++return+String.Empty;
}|1762978|不能传入没有参数的lambda表达式或没有参数的方法。这些是不允许的：|1762979|Test(()+=>+String.Empty);+//Not+allowed,+lambda+must+match+signature
Test(D2);+//Not+allowed,+method+must+match+signature

private+string+D2()
{
++++return+String.Empty;
}|1762980|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

One difference is that an anonymous delegate can omit parameters while a lambda must match the exact signature. Given:

<pre><code>public delegate string TestDelegate(int i);

public void Test(TestDelegate d)
{}
</code></pre>

you can call it in the following four ways (note that the second line has an anonymous delegate that does not have any parameters):

<pre><code>Test(delegate(int i) { return String.Empty; });
Test(delegate { return String.Empty; });
Test(i =&gt; String.Empty);
Test(D);

private string D(int i)
{
 return String.Empty;
}
</code></pre>

You cannot pass in a lambda expression that has no parameters or a method that has no parameters. These are not allowed:

<pre><code>Test(() =&gt; String.Empty); //Not allowed, lambda must match signature
Test(D2); //Not allowed, method must match signature

private string D2()
{
 return String.Empty;
}
</code></pre>

blocks|key|1763015|text|这里有一个例子，我在我的烂博客上放了一段时间。假设您想要从一个工作线程更新一个标签。我有4个例子，说明如何使用委托、无委托和2种类型的lambdas将标签从1更新到50。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1763016|+private+void+button2_Click(object+sender,+EventArgs+e)+
+++++{+
+++++++++BackgroundWorker+worker+=+new+BackgroundWorker();+
+++++++++worker.DoWork+%2B=+new+DoWorkEventHandler(worker_DoWork);+
+++++++++worker.RunWorkerAsync();+
+++++}+

+++++private+delegate+void+UpdateProgDelegate(int+count);+
+++++private+void+UpdateText(int+count)+
+++++{+
+++++++++if+(this.lblTest.InvokeRequired)+
+++++++++{+
+++++++++++++UpdateProgDelegate+updateCallBack+=+new+UpdateProgDelegate(UpdateText);+
+++++++++++++this.Invoke(updateCallBack,+new+object[]+{+count+});+
+++++++++}+
+++++++++else+
+++++++++{+
+++++++++++++lblTest.Text+=+count.ToString();+
+++++++++}+
+++++}+

+++++void+worker_DoWork(object+sender,+DoWorkEventArgs+e)+
+++++{+++
+++++++++/*+Old+Skool+delegate+usage.++See+above+for+delegate+and+method+definitions+*/+
+++++++++for+(int+i+=+0;+i+<+50;+i%2B%2B)+
+++++++++{+
+++++++++++++UpdateText(i);+
+++++++++++++Thread.Sleep(50);+
+++++++++}+

+++++++++//+Anonymous+Method+
+++++++++for+(int+i+=+0;+i+<+50;+i%2B%2B)+
+++++++++{+
+++++++++++++lblTest.Invoke((MethodInvoker)(delegate()+
+++++++++++++{+
+++++++++++++++++lblTest.Text+=+i.ToString();+
+++++++++++++}));+
+++++++++++++Thread.Sleep(50);+
+++++++++}+

+++++++++/*+Lambda+using+the+new+Func+delegate.+This+lets+us+take+in+an+int+and+
++++++++++*+return+a+string.++The+last+parameter+is+the+return+type.+so+
++++++++++*+So+Func<int,+string,+double>+would+take+in+an+int+and+a+string+
++++++++++*+and+return+a+double.++count+is+our+int+parameter.*/+
+++++++++Func<int,+string>+UpdateProgress+=+(count)+=>+lblTest.Text+=+count.ToString();+
+++++++++for+(int+i+=+0;+i+<+50;+i%2B%2B)+
+++++++++{+
+++++++++++++lblTest.Invoke(UpdateProgress,+i);+
+++++++++++++Thread.Sleep(50);+
+++++++++}+

+++++++++/*+Finally+we+have+a+totally+inline+Lambda+using+the+Action+delegate+
++++++++++*+Action+is+more+or+less+the+same+as+Func+but+it+returns+void.+We+could+
++++++++++*+use+it+with+parameters+if+we+wanted+to+like+this:+
++++++++++*+Action<string>+UpdateProgress+=+(count)+=>+lblT…*/+
+++++++++for+(int+i+=+0;+i+<+50;+i%2B%2B)+
+++++++++{+
+++++++++++++lblTest.Invoke((Action)(()+=>+lblTest.Text+=+i.ToString()));+
+++++++++++++Thread.Sleep(50);+
+++++++++}+
+++++}|code-block|syntax|javascript|1763017|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Heres an example I put up awhile on my lame blog. Say you wanted to update a label from a worker thread. I've got 4 examples of how to update that label from 1 to 50 using delegates, anon delegates and 2 types of lambdas.

<pre><code> private void button2_Click(object sender, EventArgs e) 
 { 
 BackgroundWorker worker = new BackgroundWorker(); 
 worker.DoWork += new DoWorkEventHandler(worker_DoWork); 
 worker.RunWorkerAsync(); 
 } 

 private delegate void UpdateProgDelegate(int count); 
 private void UpdateText(int count) 
 { 
 if (this.lblTest.InvokeRequired) 
 { 
 UpdateProgDelegate updateCallBack = new UpdateProgDelegate(UpdateText); 
 this.Invoke(updateCallBack, new object[] { count }); 
 } 
 else 
 { 
 lblTest.Text = count.ToString(); 
 } 
 } 

 void worker_DoWork(object sender, DoWorkEventArgs e) 
 { 
 /* Old Skool delegate usage. See above for delegate and method definitions */ 
 for (int i = 0; i &lt; 50; i++) 
 { 
 UpdateText(i); 
 Thread.Sleep(50); 
 } 

 // Anonymous Method 
 for (int i = 0; i &lt; 50; i++) 
 { 
 lblTest.Invoke((MethodInvoker)(delegate() 
 { 
 lblTest.Text = i.ToString(); 
 })); 
 Thread.Sleep(50); 
 } 

 /* Lambda using the new Func delegate. This lets us take in an int and 
 * return a string. The last parameter is the return type. so 
 * So Func&lt;int, string, double&gt; would take in an int and a string 
 * and return a double. count is our int parameter.*/ 
 Func&lt;int, string&gt; UpdateProgress = (count) =&gt; lblTest.Text = count.ToString(); 
 for (int i = 0; i &lt; 50; i++) 
 { 
 lblTest.Invoke(UpdateProgress, i); 
 Thread.Sleep(50); 
 } 

 /* Finally we have a totally inline Lambda using the Action delegate 
 * Action is more or less the same as Func but it returns void. We could 
 * use it with parameters if we wanted to like this: 
 * Action&lt;string&gt; UpdateProgress = (count) =&gt; lblT…*/ 
 for (int i = 0; i &lt; 50; i++) 
 { 
 lblTest.Invoke((Action)(() =&gt; lblTest.Text = i.ToString())); 
 Thread.Sleep(50); 
 } 
 }
</code></pre>

blocks|key|1763041|text|委托是对具有特定参数列表和返回类型的方法的引用。它可能包含也可能不包含对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1763042|lambda表达式是匿名函数的一种形式。|1763043|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

A delegate is a reference to a method with a particular parameter list and return type. It may or may not include an object.

A lambda-expression is a form of anonymous function.

blocks|key|1763083|text|一个委托是一个函数指针队列，调用一个委托可以调用多个方法。lambda本质上是一个匿名方法声明，编译器可能会根据它用作什么上下文而对其进行不同的解释。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1763084|您可以通过将lambda表达式转换为委托来获取指向该表达式的方法的委托，或者如果将其作为参数传递给需要特定委托类型的方法，则编译器将为您转换该委托。在LINQ语句中使用它，编译器会将lambda转换为表达式树，而不是简单的委托。|1763085|真正的区别在于，lambda是在另一个表达式中定义方法的一种简洁方式，而委托是实际的对象类型。|1763086|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

A delegate is a Queue of function pointers, invoking a delegate may invoke multiple methods. A lambda is essentially an anonymous method declaration which may be interpreted by the compiler differently, depending on what context it is used as.

You can get a delegate that points to the lambda expression as a method by casting it into a delegate, or if passing it in as a parameter to a method that expects a specific delegate type the compiler will cast it for you. Using it inside of a LINQ statement, the lambda will be translated by the compiler into an expression tree instead of simply a delegate.

The difference really is that a lambda is a terse way to define a method inside of another expression, while a delegate is an actual object type.

I get asked this question a lot and I thought I'd solicit some input on how to best describe the difference.

What is the difference between lambdas and delegates in the .NET Framework?

编译器

我经常被问到这个问题，我想我应该征求一些关于如何最好地描述差异的意见。

问在.NET框架中，lambdas和委托有什么不同？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在.NET框架中，lambdas和委托有什么不同？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在.NET框架中，lambdas和委托有什么不同？
EN