我有一篇关于这个主题的文章。(书中有很多例子。)

从本质上讲，闭包是一段可以在以后执行的代码，但它维护了它第一次创建时的环境——即它仍然可以使用创建它的方法的局部变量等，即使该方法已经执行完毕。

闭包的一般特性是通过匿名方法和lambda表达式在c#中实现的。

下面是一个使用匿名方法的例子:

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);
        };
    }
}

输出:

counter=1
counter=2

在这里，我们可以看到CreateAction返回的操作仍然可以访问counter变量，并且确实可以增加它，即使CreateAction本身已经完成。

闭包是在函数中定义的函数，可以访问它的局部变量以及它的父变量。

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

find方法中的函数。

t => t.Name == name

可以访问其作用域中的变量t，以及父作用域中的变量名。即使它是由find方法作为委托从另一个作用域执行的。

我有一篇关于这个主题的文章。(书中有很多例子。)

从本质上讲，闭包是一段可以在以后执行的代码，但它维护了它第一次创建时的环境——即它仍然可以使用创建它的方法的局部变量等，即使该方法已经执行完毕。

闭包的一般特性是通过匿名方法和lambda表达式在c#中实现的。

下面是一个使用匿名方法的例子:

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);
        };
    }
}

输出:

counter=1
counter=2

在这里，我们可以看到CreateAction返回的操作仍然可以访问counter变量，并且确实可以增加它，即使CreateAction本身已经完成。

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...

闭包是在另一个函数(或方法)中定义的函数，它使用父方法中的变量。这种位于方法中并包装在其中定义的函数中的变量的使用称为闭包。

Mark Seemann在他的博客文章中有一些关于闭包的有趣例子，他将面向对象编程和函数式编程进行了比较。

让它更详细

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

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.