blocks|key|1981668|text|闭包是函数值，它从原来的作用域内保存变量值。C#可以以匿名委托的形式使用它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1981669|对于一个非常简单的例子，以下面的C#代码为例：|1981670|++++delegate+int+testDel();

++++static+void+Main(string[]+args)
++++{
++++++++int+foo+=+4;
++++++++testDel+myClosure+=+delegate()
++++++++{
++++++++++++return+foo;
++++++++};
++++++++int+bar+=+myClosure();

++++}|code-block|syntax|javascript|1981671|在它的末尾，bar将被设置为4，myClosure委托可以传递到程序的其他地方使用。|1981672|闭包可以用于许多有用的事情，比如延迟执行或简化接口-+LINQ主要是使用闭包构建的。对大多数开发人员来说，最直接的方法是向动态创建的控件中添加事件处理程序--您可以在控件实例化时使用闭包来添加行为，而不是将数据存储在其他地方。|1981673|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Closures are functional values that hold onto variable values from their original scope. C# can use them in the form of anonymous delegates.

For a very simple example, take this C# code:

<pre><code> delegate int testDel();

 static void Main(string[] args)
 {
 int foo = 4;
 testDel myClosure = delegate()
 {
 return foo;
 };
 int bar = myClosure();

 }
</code></pre>

At the end of it, bar will be set to 4, and the myClosure delegate can be passed around to be used elsewhere in the program.

Closures can be used for a lot of useful things, like delayed execution or to simplify interfaces - LINQ is mainly built using closures. The most immediate way it comes in handy for most developers is adding event handlers to dynamically created controls - you can use closures to add behavior when the control is instantiated, rather than storing data elsewhere.

blocks|key|1981711|text|我有一篇关于这个主题的文章。(它有很多例子。)|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1981712|从本质上说，闭包是一个代码块，可以在以后执行，但它维护最初创建它的环境--也就是说，即使在该方法完成执行之后，它仍然可以使用创建它的方法的局部变量等。|1981713|闭包的一般特性是通过匿名方法和lambda表达式在C#中实现的。|1981714|下面是一个使用匿名方法的示例：|1981715|using+System;

class+Test
{
++++static+void+Main()
++++{
++++++++Action+action+=+CreateAction();
++++++++action();
++++++++action();
++++}

++++static+Action+CreateAction()
++++{
++++++++int+counter+=+0;
++++++++return+delegate
++++++++{
++++++++++++//+Yes,+it+could+be+done+in+one+statement;+
++++++++++++//+but+it+is+clearer+like+this.
++++++++++++counter%2B%2B;
++++++++++++Console.WriteLine("counter={0}",+counter);
++++++++};
++++}
}|code-block|syntax|javascript|1981716|输出：|1981717|counter=1
counter=2|1981718|在这里，我们可以看到，CreateAction返回的操作仍然可以访问计数器变量，并且确实可以增加它，即使CreateAction本身已经完成。|1981719|entityMap|0|LINK|mutability|MUTABLE|url|http://csharpindepth.com/Articles/Chapter5/Closures.aspx^0|2|B|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|17|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|18|8|@]|9|@]|C|$]]|$1|J|3|K|5|L|7|19|8|@]|9|@]|C|$M|N]]|$1|O|3|P|5|6|7|1A|8|@]|9|@]|C|$]]|$1|Q|3|R|5|L|7|1B|8|@]|9|@]|C|$M|N]]|$1|S|3|T|5|6|7|1C|8|@]|9|@]|C|$]]|$1|U|3|-4|5|6|7|1D|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]]]

I have <a href="http://csharpindepth.com/Articles/Chapter5/Closures.aspx" rel="noreferrer">an article on this very topic</a>. (It has lots of examples.)

In essence, a closure is a block of code which can be executed at a later time, but which maintains the environment in which it was first created - i.e. it can still use the local variables etc of the method which created it, even after that method has finished executing.

The general feature of closures is implemented in C# by anonymous methods and lambda expressions.

Here's an example using an anonymous method:

<pre><code>using System;

class Test
{
 static void Main()
 {
 Action action = CreateAction();
 action();
 action();
 }

 static Action CreateAction()
 {
 int counter = 0;
 return delegate
 {
 // Yes, it could be done in one statement; 
 // but it is clearer like this.
 counter++;
 Console.WriteLine("counter={0}", counter);
 };
 }
}
</code></pre>

Output:

<pre><code>counter=1
counter=2
</code></pre>

Here we can see that the action returned by CreateAction still has access to the counter variable, and can indeed increment it, even though CreateAction itself has finished.

blocks|key|757936|text|闭包是在函数中定义的函数，它可以访问函数及其父函数的局部变量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|757937|public+string+GetByName(string+name)
{
+++List<things>+theThings+=+new+List<things>();
++return++theThings.Find<things>(t+=>+t.Name+==+name)[0];
}|code-block|syntax|javascript|757938|所以find方法中的函数。|757939|+t+=>+t.Name+==+name|757940|可以访问其作用域t和其父作用域中的变量名中的变量。尽管它是由find方法作为委托来执行的，但它是从另一个范围一起执行的。|757941|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

A closure is a function, defined within a function, that can access the local variables of it as well as its parent.

<pre><code>public string GetByName(string name)
{
 List&lt;things&gt; theThings = new List&lt;things&gt;();
 return theThings.Find&lt;things&gt;(t =&gt; t.Name == name)[0];
}
</code></pre>

so the function inside the find method. 

<pre><code> t =&gt; t.Name == name
</code></pre>

can access the variables inside its scope, t, and the variable name which is in its parents scope. Even though it is executed by the find method as a delegate, from another scope all together.

blocks|key|448116|text|Func<int,+int>+GetMultiplier(int+a)
{
+++++return+delegate(int+b)+{+return+a+*+b;+}+;
}
//...
var+fn2+=+GetMultiplier(2);
var+fn3+=+GetMultiplier(3);
Console.WriteLine(fn2(2));++//outputs+4
Console.WriteLine(fn2(3));++//outputs+6
Console.WriteLine(fn3(2));++//outputs+6
Console.WriteLine(fn3(3));++//outputs+9|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|448117|闭包是在其创建函数之外传递的匿名函数。它维护它所使用的函数中的任何变量。|unstyled|448118|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>Func&lt;int, int&gt; GetMultiplier(int a)
{
 return delegate(int b) { return a * b; } ;
}
//...
var fn2 = GetMultiplier(2);
var fn3 = GetMultiplier(3);
Console.WriteLine(fn2(2)); //outputs 4
Console.WriteLine(fn2(3)); //outputs 6
Console.WriteLine(fn3(2)); //outputs 6
Console.WriteLine(fn3(3)); //outputs 9
</code></pre>

A closure is an anonymous function passed outside of the function in which it is created.
It maintains any variables from the function in which it is created that it uses.

blocks|key|757330|text|闭包是引用外部变量(从堆栈的下面)引用变量的代码块，以后可能会调用或执行这些变量(比如定义了事件或委托，并可能在未来某个不确定的时间点被调用).由于代码块引用的外部变量可能超出了作用域(否则会丢失)，因此代码块(称为闭包)引用它的事实告诉运行库在范围内“保持”该变量，直到代码块不再需要它.|type|unstyled|depth|inlineStyleRanges|entityRanges|data|757331|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|$]]

Closures are chunks of code that reference a variable outside themselves, (from below them on the stack), that might be called or executed later, (like when an event or delegate is defined, and could get called at some indefinite future point in time)... Because the outside variable that the chunk of code references may gone out of scope (and would otherwise have been lost), the fact that it is referenced by the chunk of code (called a closure) tells the runtime to "hold" that variable in scope until it is no longer needed by the closure chunk of code...

blocks|key|1981827|text|下面是一个为C#设计的示例，它是我从JavaScript中的类似代码创建的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1981828|public+delegate+T+Iterator<T>()+where+T+:+class;

public+Iterator<T>+CreateIterator<T>(IList<T>+x)+where+T+:+class
{
++++++++var+i+=+0;+
++++++++return+delegate+{+return+(i+<+x.Count)+?+x[i%2B%2B]+:+null;+};
}|code-block|syntax|javascript|1981829|这里有一些代码展示了如何使用上面的代码..。|1981830|var+iterator+=+CreateIterator(new+string[3]+{+"Foo",+"Bar",+"Baz"});

//+So,+although+CreateIterator()+has+been+called+and+returned,+the+variable+
//+"i"+within+CreateIterator()+will+live+on+because+of+a+closure+created+
//+within+that+method,+so+that+every+time+the+anonymous+delegate+returned+
//+from+it+is+called+(by+calling+iterator())+it's+value+will+increment.

string+currentString;++++
currentString+=+iterator();+//+currentString+is+now+"Foo"
currentString+=+iterator();+//+currentString+is+now+"Bar"
currentString+=+iterator();+//+currentString+is+now+"Baz"
currentString+=+iterator();+//+currentString+is+now+null|1981831|希望这会有所帮助。|1981832|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Here is a contrived example for C# which I created from similar code in JavaScript:

<pre><code>public delegate T Iterator&lt;T&gt;() where T : class;

public Iterator&lt;T&gt; CreateIterator&lt;T&gt;(IList&lt;T&gt; x) where T : class
{
 var i = 0; 
 return delegate { return (i &lt; x.Count) ? x[i++] : null; };
}
</code></pre>

So, here is some code that shows how to use the above code...

<pre><code>var iterator = CreateIterator(new string[3] { "Foo", "Bar", "Baz"});

// So, although CreateIterator() has been called and returned, the variable 
// "i" within CreateIterator() will live on because of a closure created 
// within that method, so that every time the anonymous delegate returned 
// from it is called (by calling iterator()) it's value will increment.

string currentString; 
currentString = iterator(); // currentString is now "Foo"
currentString = iterator(); // currentString is now "Bar"
currentString = iterator(); // currentString is now "Baz"
currentString = iterator(); // currentString is now null
</code></pre>

Hope that is somewhat helpful.

blocks|key|1981858|text|基本上，闭包是一个代码块，您可以将它作为参数传递给函数。C#以匿名委托的形式支持闭包。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1981859|下面是一个简单的例子：|1981860|List.Find方法可以接受并执行一段代码(闭包)来查找列表的项。|1981861|//+Passing+a+block+of+code+as+a+function+argument
List<int>+ints+=+new+List<int>+{1,+2,+3};
ints.Find(delegate(int+value)+{+return+value+==+1;+});|code-block|syntax|javascript|1981862|使用C#3.0语法，我们可以将其编写为：|1981863|ints.Find(value+=>+value+==+1);|1981864|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|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|T|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Basically closure is a block of code that you can pass as an argument to a function. C# supports closures in form of anonymous delegates.

Here is a simple example: 
List.Find method can accept and execute piece of code (closure) to find list's item.

<pre><code>// Passing a block of code as a function argument
List&lt;int&gt; ints = new List&lt;int&gt; {1, 2, 3};
ints.Find(delegate(int value) { return value == 1; });
</code></pre>

Using C#3.0 syntax we can write this as: 

<pre><code>ints.Find(value =&gt; value == 1);
</code></pre>

blocks|key|448224|text|如果您对C#如何实现闭包感兴趣，请阅读“我知道答案(+42)博客”|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|448225|编译器在后台生成一个类来封装阳极方法和变量j。|448226|[CompilerGenerated]
private+sealed+class+<>c__DisplayClass2
{
++++public+<>c__DisplayClass2();
++++public+void+<fillFunc>b__0()
++++{
+++++++Console.Write("{0}+",+this.j);
++++}
++++public+int+j;
}|code-block|syntax|javascript|448227|职能方面：|448228|static+void+fillFunc(int+count)+{
++++for+(int+i+=+0;+i+<+count;+i%2B%2B)
++++{
++++++++int+j+=+i;
++++++++funcArr[i]+=+delegate()
+++++++++++++++++++++{
+++++++++++++++++++++++++Console.Write("{0}+",+j);
+++++++++++++++++++++};
++++}+
}|448229|将其转化为：|448230|private+static+void+fillFunc(int+count)
{
++++for+(int+i+=+0;+i+<+count;+i%2B%2B)
++++{
++++++++Program.<>c__DisplayClass1+class1+=+new+Program.<>c__DisplayClass1();
++++++++class1.j+=+i;
++++++++Program.funcArr[i]+=+new+Func(class1.<fillFunc>b__0);
++++}
}|448231|entityMap|0|LINK|mutability|MUTABLE|url|http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx^0|J|E|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|15|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|17|8|@]|9|@]|C|$I|J]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|C|$]]|$1|Q|3|R|5|H|7|19|8|@]|9|@]|C|$I|J]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]]]

If you are interested in seeing how C# implements Closure read <a href="http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx" rel="noreferrer">"I know the answer (its 42) blog"</a>

The compiler generates a class in the background to encapsulate the anoymous method and the variable j

<pre><code>[CompilerGenerated]
private sealed class &lt;&gt;c__DisplayClass2
{
 public &lt;&gt;c__DisplayClass2();
 public void &lt;fillFunc&gt;b__0()
 {
 Console.Write("{0} ", this.j);
 }
 public int j;
}
</code></pre>

for the function:

<pre><code>static void fillFunc(int count) {
 for (int i = 0; i &lt; count; i++)
 {
 int j = i;
 funcArr[i] = delegate()
 {
 Console.Write("{0} ", j);
 };
 } 
}
</code></pre>

Turning it into:

<pre><code>private static void fillFunc(int count)
{
 for (int i = 0; i &lt; count; i++)
 {
 Program.&lt;&gt;c__DisplayClass1 class1 = new Program.&lt;&gt;c__DisplayClass1();
 class1.j = i;
 Program.funcArr[i] = new Func(class1.&lt;fillFunc&gt;b__0);
 }
}
</code></pre>

blocks|key|448260|text|闭包是指在另一个函数(或方法)中定义一个函数，并使用父方法中的变量。这种使用位于方法中并包装在其中定义的函数中的变量称为闭包。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|448261|Mark在他的博客文章中有一些有趣的闭包示例，他在oop和函数式编程之间做了一个副词。|offset|length|448262|让它更详细|448263|var+workingDirectory+=+new+DirectoryInfo(Environment.CurrentDirectory);//when+this+variable
Func<int,+string>+read+=+id+=>
++++{
++++++++var+path+=+Path.Combine(workingDirectory.FullName,+id+%2B+".txt");//is+used+inside+this+function
++++++++return+File.ReadAllText(path);
++++};//the+entire+process+is+called+a+closure.|code-block|syntax|javascript|448264|entityMap|0|LINK|mutability|MUTABLE|url|http://blog.ploeh.dk/2014/03/10/solid-the-next-step-is-functional/^0|0|5|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@$D|W|E|X|1|Y]]|A|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

A closure is when a function is defined inside another function (or method) and it uses the variables from the parent method. This use of variables which are located in a method and wrapped in a function defined within it, is called a closure. 

Mark Seemann has some interesting examples of closures in <a href="http://blog.ploeh.dk/2014/03/10/solid-the-next-step-is-functional/" rel="nofollow noreferrer">his blog post</a> where he does a paralel between oop and functional programming.

And to make it more detailed

<pre><code>var workingDirectory = new DirectoryInfo(Environment.CurrentDirectory);//when this variable
Func&lt;int, string&gt; read = id =&gt;
 {
 var path = Path.Combine(workingDirectory.FullName, id + ".txt");//is used inside this function
 return File.ReadAllText(path);
 };//the entire process is called a closure.
</code></pre>

blocks|key|1981965|text|只是意外的，一个简单和更理解的答案从书C#+7.0简要。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1981966|预请求您应该知道：lambda表达式可以引用定义它的方法的局部变量和参数(外部变量)。|offset|length|style|BOLD|1981967|++++static+void+Main()
++++{
++++int+factor+=+2;
+++//Here+factor+is+the+variable+that+takes+part+in+lambda+expression.
++++Func<int,+int>+multiplier+=+n+=>+n+*+factor;
++++Console.WriteLine+(multiplier+(3));+//+6
++++}|code-block|syntax|javascript|1981968|实部件：由lambda表达式引用的外部变量称为捕获变量。捕获变量的lambda表达式称为闭包。|1981969|需要注意的最后一点：捕获的变量是在实际调用委托时计算的，而不是在捕获变量时计算的：|1981970|int+factor+=+2;
Func<int,+int>+multiplier+=+n+=>+n+*+factor;
factor+=+10;
Console.WriteLine+(multiplier+(3));+//+30|1981971|entityMap^0|0|0|8|0|0|0|3|0|5|4|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|Z|8|@$D|10|E|11|F|G]]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@$D|13|E|14|F|G]]|9|@]|A|$]]|$1|Q|3|R|5|J|7|15|8|@]|9|@]|A|$K|L]]|$1|S|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|T|$]]

Just out of the blue,a simple and more understanding answer from the book C# 7.0 nutshell.

Pre-requisit you should know :A lambda expression can reference the local variables and parameters of the method
in which it’s defined (outer variables).

<pre><code> static void Main()
 {
 int factor = 2;
 //Here factor is the variable that takes part in lambda expression.
 Func&lt;int, int&gt; multiplier = n =&gt; n * factor;
 Console.WriteLine (multiplier (3)); // 6
 }
</code></pre>

Real part:Outer variables referenced by a lambda expression are called captured variables. A lambda expression that captures variables is called a closure.

Last Point to be noted:Captured variables are evaluated when the delegate is actually invoked, not when the variables were captured:

<pre><code>int factor = 2;
Func&lt;int, int&gt; multiplier = n =&gt; n * factor;
factor = 10;
Console.WriteLine (multiplier (3)); // 30
</code></pre>

blocks|key|448342|text|如果您编写内联匿名方法(C#2)或(最好是)+Lambda表达式(C#3%2B)，则仍将创建实际的方法。如果该代码使用的是外部局部变量，则仍然需要将该变量以某种方式传递给该方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|448343|例如，使用这个Linq子句(它是一个简单的扩展方法，它传递一个lambda表达式)：|448344|var+i+=+0;
var+items+=+new+List<string>
{
++++"Hello","World"
};+++
var+filtered+=+items.Where(x+=>
//+this+is+a+predicate,+i.e.+a+Func<T,+bool>+written+as+a+lambda+expression
//+which+is+still+a+method+actually+being+created+for+you+in+compile+time+
{
++++i%2B%2B;
++++return+true;
});|code-block|syntax|javascript|448345|如果要在lambda表达式中使用i，则必须将其传递给已创建的方法。|448346|因此出现的第一个问题是：是通过值传递还是通过引用传递？|offset|length|style|BOLD|448347|通过引用传递(我想)更可取，因为您可以访问该变量(这就是C#所做的；我猜微软团队权衡了利弊，并进行了间接引用；根据乔恩·斯基特的文章的说法，Java是按值运行的)。|448348|但随后又出现了另一个问题：在哪里分配i?|448349|它应该实际/自然地分配到堆栈上吗？如果您在堆栈上分配它并通过引用传递它，那么在某些情况下，它会超过它自己的堆栈框架。举个例子：|448350|static+void+Main(string[]+args)
{
++++Outlive();
++++var+list+=+whereItems.ToList();
++++Console.ReadLine();
}

static+IEnumerable<string>+whereItems;

static+void+Outlive()
{
++++var+i+=+0;
++++var+items+=+new+List<string>
++++{
++++++++"Hello","World"
++++};++++++++++++
++++whereItems+=+items.Where(x+=>
++++{
++++++++i%2B%2B;
++++++++Console.WriteLine(i);
++++++++return+true;
++++});++++++++++++
}|448351|lambda表达式(在Where子句中)再次创建了一个引用i的方法。如果我被分配到过期堆栈上，那么在枚举whereItems时，生成的方法中使用的I将指向过时的I，即堆栈中无法访问的位置。|448352|好吧，那我们就把它放在堆里。|448353|因此，C#编译器支持这个内联匿名/lambda的方法是使用所谓的“闭包”：它在Heap上创建一个名为(相当差)+DisplayClass的类，其中包含一个包含i的字段，以及实际使用它的函数。|448354|与此等价的东西(您可以看到使用ILSpy或ILDASM生成的IL+)：|448355|class+<>c_DisplayClass1
{
++++public+int+i;

++++public+bool+<GetFunc>b__0()
++++{
++++++++this.i%2B%2B;
++++++++Console.WriteLine(i);
++++++++return+true;
++++}
}|448356|它在本地作用域中实例化该类，并用该闭包实例替换与I或lambda表达式相关的任何代码。因此，每当您在定义我的“本地范围”代码中使用i时，您实际上都在使用DisplayClass实例字段。|448357|因此，如果我要更改主方法中的“本地”i，它实际上将更改_DisplayClass.i；|448358|即|448359|var+i+=+0;
var+items+=+new+List<string>
{
++++"Hello","World"
};++
var+filtered+=+items.Where(x+=>
{
++++i%2B%2B;
++++return+true;
});
filtered.ToList();+//+will+enumerate+filtered,+i+=+2
i+=+10;++++++++++++//+i+will+be+overwriten+with+10
filtered.ToList();+//+will+enumerate+filtered+again,+i+=+12
Console.WriteLine(i);+//+should+print+out+12|448360|它将打印出12，因为"i+=+10“到那个驱散类字段，并在第二次枚举之前更改它。|448361|关于这个主题的一个很好的来源是这个Bart+De+Smet+Pluralsight模块+(需要注册)(也忽略了他错误地使用了术语“提升”--我认为他的意思是局部变量(即i)被更改为引用新的DisplayClass字段)。|448362|在其他新闻中，似乎存在一些误解，认为“闭包”与循环有关--据我所知，“闭包”不是一个与循环相关的概念，而是与使用局部作用域变量的匿名方法/+lambda表达式有关--尽管一些技巧问题使用循环来演示它。|448363|entityMap|0|LINK|mutability|MUTABLE|url|http://csharpindepth.com/Articles/Chapter5/Closures.aspx|1|https://stackoverflow.com/a/16403470/6296435|2|https://app.pluralsight.com/player?course=csharp-language-internals&author=bart-desmet&name=csharp-language-internals-m5&clip=4&mode=live^0|0|0|0|0|C|F|0|1L|9|0|0|D|7|0|0|0|0|0|X|2|1F|3|1|0|0|0|0|0|0|0|0|H|Q|2|0|Y|B|0^^$0|@$1|2|3|4|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|20|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|21|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|22|8|@$M|23|N|24|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|25|8|@]|9|@$M|26|N|27|1|28]]|A|$]]|$1|S|3|T|5|6|7|29|8|@$M|2A|N|2B|O|P]]|9|@]|A|$]]|$1|U|3|V|5|6|7|2C|8|@]|9|@]|A|$]]|$1|W|3|X|5|F|7|2D|8|@]|9|@]|A|$G|H]]|$1|Y|3|Z|5|6|7|2E|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|2F|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|2G|8|@$M|2H|N|2I|O|P]]|9|@$M|2J|N|2K|1|2L]]|A|$]]|$1|14|3|15|5|6|7|2M|8|@]|9|@]|A|$]]|$1|16|3|17|5|F|7|2N|8|@]|9|@]|A|$G|H]]|$1|18|3|19|5|6|7|2O|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|2P|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|2Q|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|F|7|2R|8|@]|9|@]|A|$G|H]]|$1|1G|3|1H|5|6|7|2S|8|@]|9|@]|A|$]]|$1|1I|3|1J|5|6|7|2T|8|@]|9|@$M|2U|N|2V|1|2W]]|A|$]]|$1|1K|3|1L|5|6|7|2X|8|@$M|2Y|N|2Z|O|P]]|9|@]|A|$]]|$1|1M|3|-4|5|6|7|30|8|@]|9|@]|A|$]]]|1N|$1O|$5|1P|1Q|1R|A|$1S|1T]]|1U|$5|1P|1Q|1R|A|$1S|1V]]|1W|$5|1P|1Q|1R|A|$1S|1X]]]]

If you write an inline anonymous method (C#2) or (preferably) a Lambda expression (C#3+), an actual method is still being created. If that code is using an outer-scope local variable - you still need to pass that variable to the method somehow. 

e.g. take this Linq Where clause (which is a simple extension method which passes a lambda expression):

<pre><code>var i = 0;
var items = new List&lt;string&gt;
{
 "Hello","World"
}; 
var filtered = items.Where(x =&gt;
// this is a predicate, i.e. a Func&lt;T, bool&gt; written as a lambda expression
// which is still a method actually being created for you in compile time 
{
 i++;
 return true;
});
</code></pre>

if you want to use i in that lambda expression, you have to pass it to that created method.

So the first question that arises is: should it be passed by value or reference? 

Pass by reference is (I guess) more preferable as you get read/write access to that variable (and this is what C# does; I guess the team in Microsoft weighed the pros and cons and went with by-reference; According to <a href="http://csharpindepth.com/Articles/Chapter5/Closures.aspx" rel="nofollow noreferrer">Jon Skeet's article</a>, Java went with by-value). 

But then another question arises: Where to allocate that i? 

Should it actually/naturally be allocated on the stack? 
Well, if you allocate it on the stack and pass it by reference, there can be situations where it outlives it's own stack frame. Take this example:

<pre><code>static void Main(string[] args)
{
 Outlive();
 var list = whereItems.ToList();
 Console.ReadLine();
}

static IEnumerable&lt;string&gt; whereItems;

static void Outlive()
{
 var i = 0;
 var items = new List&lt;string&gt;
 {
 "Hello","World"
 }; 
 whereItems = items.Where(x =&gt;
 {
 i++;
 Console.WriteLine(i);
 return true;
 }); 
}
</code></pre>

The lambda expression (in the Where clause) again creates a method which refers to an i. If i is allocated on the stack of Outlive, then by the time you enumerate the whereItems, the i used in the generated method will point to the i of Outlive, i.e. to a place in the stack that is no longer accessible. 

Ok, so we need it on the heap then. 

So what the C# compiler does to support this inline anonymous/lambda, is use what is called "Closures": It creates a class on the Heap called (<a href="https://stackoverflow.com/a/16403470/6296435">rather poorly</a>) DisplayClass which has a field containing the i, and the Function that actually uses it. 

Something that would be equivalent to this (you can see the IL generated using ILSpy or ILDASM):

<pre><code>class &lt;&gt;c_DisplayClass1
{
 public int i;

 public bool &lt;GetFunc&gt;b__0()
 {
 this.i++;
 Console.WriteLine(i);
 return true;
 }
}
</code></pre>

It instantiates that class in your local scope, and replaces any code relating to i or the lambda expression with that closure instance. So - anytime you are using the i in your "local scope" code where i was defined, you are actually using that DisplayClass instance field. 

So if I would change the "local" i in the main method, it will actually change _DisplayClass.i ; 

i.e. 

<pre><code>var i = 0;
var items = new List&lt;string&gt;
{
 "Hello","World"
}; 
var filtered = items.Where(x =&gt;
{
 i++;
 return true;
});
filtered.ToList(); // will enumerate filtered, i = 2
i = 10; // i will be overwriten with 10
filtered.ToList(); // will enumerate filtered again, i = 12
Console.WriteLine(i); // should print out 12
</code></pre>

it will print out 12, as "i = 10" goes to that dispalyclass field and changes it just before the 2nd enumeration. 

A good source on the topic is this <a href="https://app.pluralsight.com/player?course=csharp-language-internals&amp;author=bart-desmet&amp;name=csharp-language-internals-m5&amp;clip=4&amp;mode=live" rel="nofollow noreferrer">Bart De Smet Pluralsight module</a> (requires registration) (also ignore his erroneous use of the term "Hoisting" - what (I think) he means is that the local variable (i.e. i) is changed to refer to the the new DisplayClass field).

<hr>

In other news, there seems to be some misconception that "Closures" are related to loops - as I understand "Closures" are NOT a concept related to loops, but rather to anonymous methods / lambda expressions use of local scoped variables - although some trick questions use loops to demonstrate it.

blocks|key|448390|text|闭包旨在简化功能思维，并允许运行时管理状态，为开发人员释放额外的复杂性。闭包是一个在词法环境中绑定自由变量的一流函数.在这些流行词背后隐藏着一个简单的概念:闭包是一种更方便的方式，可以让函数访问本地状态，并将数据传递到后台操作。它们是一些特殊的函数，它将隐式绑定到所引用的所有非局部变量(也称为空闲变量或向上值)。此外，闭包允许函数访问一个或多个非局部变量，即使在其直接词法作用域之外调用时也是如此，而且这个特殊函数的主体可以将这些自由变量作为一个单独的实体传输，该实体在其封闭作用域中定义。更重要的是，闭包封装行为并像任何其他对象一样传递它，授予对创建闭包的上下文的访问、读取和更新这些值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|448391|​|448392|📷|atomic|offset|length|448393|448394|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/0343d6e0e46a1b0bb7e6ac8882dcbfd4.png|imageAlt^0|0|0|0|1|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@$G|V|H|W|1|X]]|A|$]]|$1|I|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q|R|-4]]]]

A closure aims to simplify functional thinking, and it allows the runtime to manage
state, releasing extra complexity for the developer. A closure is a first-class function
with free variables that are bound in the lexical environment. Behind these buzzwords
hides a simple concept: closures are a more convenient way to give functions access
to local state and to pass data into background operations. They are special functions
that carry an implicit binding to all the nonlocal variables (also called free variables or
up-values) referenced. Moreover, a closure allows a function to access one or more nonlocal variables even when invoked outside its immediate lexical scope, and the body
of this special function can transport these free variables as a single entity, defined in
its enclosing scope. More importantly, a closure encapsulates behavior and passes it
around like any other object, granting access to the context in which the closure was
created, reading, and updating these values.
<a href="https://i.stack.imgur.com/EXciV.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/EXciV.png" alt="enter image description here" /></a>

What is a closure? Do we have them in .NET?

If they do exist in .NET, could you please provide a code snippet (preferably in C#) explaining it?

What are 'closures' in .NET?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

什么是结束？我们在.NET有他们吗？如果它们确实存在于.NET中，您能提供一个代码片段(最好是在C#中)来解释它吗？

问.NET中的“闭包”是什么？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问.NET中的“闭包”是什么？EN