参考https://www.bilibili.com/video/BV1sY4y1U7BT/?spm_id_from=333.337.search-card.all.click&vd_source=2a0404a7c8f40ef37a32eed32030aa18
一、什么叫闭包
1、问题引出：
不准用全局变量，也不准在调用代码块使用变量，实现计数的增加。
一般来说，用变量或对象，是可以记住上一次的状态或值，但用方法或函数是不能的。
下面的编写是不允许的，因为在a与b处定义使用了变量。
private int n = 5;//a
private static void Main(string[] args)
{
int i = 5;//b
i++;
Console.WriteLine(i);
i++;
Console.WriteLine(i);
Console.ReadKey();
}
改成下面：
private static void Main(string[] args)
{
Func<Func<int>> f = () =>
{
int i = 5;
return () =>
{
i++;
return i;
};
};
var counter = f();//a
Console.WriteLine(counter());//6
Console.WriteLine(counter());//7
Console.WriteLine(f()());//6
Console.WriteLine(f()());//6
Console.ReadKey();
}
上面没有用变量，只是用一个方法，每一次调用counter()值就自动增加，实现了题目的要求。
问：上面输出的最后两次为什么一直是6？
答：反编译上面，编译器会将上面:
int i = 5;
return () =>
{
i++;
return i;
};
构造一个类，字段为i=5，后面的是方法。每创建一次就会实例化这个类即创建一个对象，于是这个方法它有了保存“状态”的能力。
在a处，创建这个类的对象并将对象传递给counter，所以每一次count，里面的对象就会用方法把i增加1，这就是第一次6，第二次再在原来i=6的基础上（因为这里一直引用的是counter=f()创建过来的对象），成为7.
而后面的两次都为6，因为都是在原来的i=5的基础上，重新创建一个各自不同的新对象，尽管都是新的对象，但它们的基础都是一样的i=5，所以再用方法自增是都是6.
2、什么是闭包？
闭包（closure）是指一个函数（或方法）及其相关的引用环境（包括函数内部定义的变量）的组合。简单来说，闭包是一个函数加上它能访问的自由变量（即不是全局变量，也不是函数的参数）的集合。（正如前面例子一样，i与后面方法）
在编程中，当一个函数引用了外部的变量，并且该函数可以在其定义的作用域之外被调用时，就形成了一个闭包。闭包使函数可以“记住”其创建时的上下文环境，包括外部变量的值。
闭包的一个常见应用场景是在异步编程中，特别是在使用回调函数或任务的情况下。在这种情况下，闭包可以用来捕获异步操作中的状态或上下文，并在回调函数或任务中使用。
3、为什么闭包不会污染全局变量？
答：闭包通过捕获变量的引用来工作，不会污染全局变量，并且不会浪费内存空间。闭包只是在调用时使用外部变量的当前值，而不会创建新的变量。
闭包不会污染全局变量，这是因为闭包的工作原理是通过捕获变量的引用，而不是将变量的值复制到闭包中。这意味着闭包只是引用了外部变量，并没有创建一个新的变量。
当一个闭包被创建时，它会捕获其所在作用域中的变量引用。当闭包被调用时，它可以访问和修改这些变量的值。这是因为闭包引用的是变量本身，而不是变量的副本。
由于闭包只是引用了外部变量，而不是复制变量的值，所以它不会污染全局变量。全局变量仍然保持其原来的值，而闭包只是在调用时使用了外部变量的当前值。
此外，关于内存的浪费问题，闭包并不会额外占用内存。当闭包被创建时，它只是引用了外部变量，而不会创建新的变量。因此，闭包不会浪费额外的内存空间。
4、闭包的条件：
闭包内部的函数必须引用外部函数的变量。这样，当外部函数执行完毕后，闭包仍然可以访问和修改外部变量。
private static void Main(string[] args)
{
Action a = CreateClosure();
a();//21
a();//22
Console.ReadKey();
}
private static Action CreateClosure()
{
int intInner = 20;
Action action = () =>
{
Console.WriteLine(++intInner);
};
return action;
}
上面定义了一个函数 CreateClosure，它返回一个闭包。闭包内部的函数 action 引用了外部变量 intInner。在 Main 方法中调用闭包并输出外部变量的值。可以看到，即使 CreateClosure 函数已经执行完毕，闭包仍然可以访问和使用外部变量。这是因为闭包将内部函数和外部变量封装在一起，形成了一个封闭的环境。闭包的存在使得内部函数可以继续访问和操作外部变量，即使外部函数已经执行完毕。
问：下面是闭包吗？
static void Main()
{
int outerVariable = 10;
Action closure = () =>
{
outerVariable++;
ConsoleWriteLine("Outer Variable: " + outerVariable);
};
ConsoleWriteLine("Before closure execution: " + outerVariable);
closure(); // 调用闭包
ConsoleWriteLine("After closure execution: " + outerVariable);
}
static void ConsoleWriteLine(string message)
{
Console.WriteLine(message);
}
尽管上面没有函数嵌套，但仍然是闭包。
闭包的特点是它可以持久化对外部变量的引用，并且在闭包调用之后仍然可以访问和修改这些变量的值。代码中，闭包通过引用外部变量 outerVariable，在闭包内部对其进行了修改，并输出了修改后的值。
尽管闭包中的外部变量 outerVariable 存储在外部作用域中，但这并不影响闭包的定义。闭包是通过引用外部变量来捕获其值的，而不是将其值存储在闭包内部。因此，即使外部变量 outerVariable 存储在外部作用域中，闭包仍然可以持久化对其值的引用，并在闭包内部进行访问和修改。
函数嵌套并不是闭包的必要条件。
当 lambda 表达式或 LINQ 查询表达式使用了外部变量时，它们可以被认为是闭包。闭包的使用可以提高代码的可读性和可维护性，并且使得我们能够更方便地处理复杂的逻辑和数据操作。
闭包是一个函数及其相关的引用的组合。在 lambda 表达式或 LINQ 查询表达式中，我们可以引用和使用外部的变量。这些外部变量可以是在外部作用域中声明的变量，也可以是在外部方法或类中声明的变量。当 lambda 表达式或 LINQ 查询表达式捕获了外部变量时，它们会持久化对这些变量的引用，从而形成闭包。
闭包的使用使得我们可以在 lambda 表达式或 LINQ 查询表达式内部访问和修改外部变量，这为我们提供了一种更灵活和方便的编程方式。闭包使得我们可以在函数内部使用外部变量，避免了传递参数的麻烦，并且可以在函数内部继续使用外部变量，而不受外部作用域的限制。
二、闭包的创建
1. 使用 lambda 表达式：
Lambda 表达式是一种简洁的语法形式，可以用来创建匿名方法。Lambda 表达式可以捕获外部变量，并且在闭包内部对这些变量进行访问和修改。
int outerVariable = 10;
Action closure = () =>
{
outerVariable++;
Console.WriteLine("Outer Variable: " + outerVariable);
};
closure(); // 调用闭包
上面，使用 lambda 表达式创建了一个闭包，该闭包引用了外部的变量 outerVariable。在闭包内部，我们对 outerVariable 进行了修改，并输出了修改后的值。
2. 使用委托：
委托是一种类型，可以用来引用方法。通过将方法赋值给委托，可以创建一个闭包，该闭包可以捕获外部变量。
int outerVariable = 10;
Action closure = delegate()
{
outerVariable++;
Console.WriteLine("Outer Variable: " + outerVariable);
};
closure(); // 调用闭包
上面使用匿名方法语法创建了一个闭包，该闭包引用了外部的变量 outerVariable。在闭包内部，对 outerVariable 进行了修改，并输出了修改后的值。
3. 使用方法内部的嵌套方法：
在一个方法内部，可以定义一个嵌套方法，并在嵌套方法中引用外部变量。这样，嵌套方法就成为了一个闭包。
void OuterMethod()
{
int outerVariable = 10;
void InnerMethod()
{
outerVariable++;
Console.WriteLine("Outer Variable: " + outerVariable);
}
InnerMethod(); // 调用闭包
}
上面在 OuterMethod 方法内部定义了一个嵌套方法 InnerMethod，该嵌套方法引用了外部的变量 outerVariable。在嵌套方法内部，我们对 outerVariable 进行了修改，并输出了修改后的值。
注意：嵌套只是闭包的一种方法，但闭包不一定必须有函数嵌套。
三、闭包的使用
1. 作为回调函数：
闭包可以作为回调函数传递给其他方法，以便在需要时执行特定的操作。
private static void Main(string[] args)
{
Process((result) =>
{
int b = result + 2;
Console.WriteLine(b);
});//c
Console.ReadKey();
}
private static void Process(Action<int> callback)
{
int a = 10 + 20;
callback(a);//闭包使用上面a值
}
上面ProcessData 方法接受一个 Action<int> 类型的回调函数作为参数。在 Main 方法中，用lambda将这个方法传过去以便闭包中使用，闭包并没有改变a的值，它只是引用了一下。 2. 保存状态：
闭包可以用于保存状态，以便在稍后的调用中使用。
public Func<int> Counter()
{
int count = 0;
return () =>
{
count++;
return count;
};
}
public void Main()
{
var counter = Counter();
Console.WriteLine(counter()); // 输出：1
Console.WriteLine(counter()); // 输出：2
Console.WriteLine(counter()); // 输出：3
}
3. 延迟执行：
闭包可以用于延迟执行一段代码，直到满足特定条件时再执行。
private static void Main(string[] args)
{
Action action = DelayExec(2);
action();
Console.ReadKey();
}
private static Action DelayExec(int s)
{
return () =>
{
Thread.Sleep(s * 1000);
Console.WriteLine($"延迟执行{s}秒");
};
}
DelayExec 方法返回一个闭包，该闭包在调用时会延迟执行一段代码，通过 Thread.Sleep 方法模拟延迟。可以在适当的时候调用闭包来触发延迟执行。
四、多线程的临时变量。
private static void Main(string[] args)
{
for (int i = 0; i < 20; i++)
{
Task.Run(() =>
{
Console.WriteLine($"{i}...");
});
}
Console.ReadKey();
}
上面结果全是20。
因为task与外面i形成闭包，每个线程都会访问i，但由于for一瞬间循环完了，i=20了，但task申请启动线程有一定的延迟，这时每个线程都会访问i，这里20就被所有线程所访问了。
但是如果我们，让循环慢一点（让子弹飞一会儿），让线程跟上节奏，先来一看Thread.Sleep(0)，这里用0，因为循环太快，用0可以查看有些相同有些不同的。
for (int i = 0; i < 20; i++)
{
Thread.Sleep(0);
Task.Run(() =>
{
Console.WriteLine($"{i}...");
});
} 
如果改为Thread.Sleep(1)，可以查看各不相同，甚至改为100，这样1-20都出来了，因为申请线程不需要这么长的时间。
当然也可以在循环的下面用task.Wait()(上面Task task=Task.Run(..))，也可得出所有i值.
但更科学的是同级别再申请的一个临时变量（推荐）
for (int i = 0; i < 20; i++)
{
int j = i;
Task.Run(() =>
{
Console.WriteLine($"{j}...");
});
}
这样，每个 lambda 表达式都会捕获一个独立的变量 j，它们的值都不相同，因此输出的结果也会不同。