C# 闭包详解

目录

闭包的含义

在C# 中使用闭包 

闭包的工作原理：

闭包的原理

头等函数

自由变量

闭包结合线程

注意事项

总结

---

闭包的含义

闭包（Closure）是一个通用的概念，适用于多种编程语言，尤其在支持函数式编程范式的语言中更为常见。

闭包的核心特点可以概括为：

• 闭包是一个函数。
• 这个函数能够访问其词法作用域（即定义时的作用域）之外的变量。
• 即使这些变量在函数执行结束后依然能够被访问。

闭包的实现方式通常是在一个函数内部定义另一个函数，并且这个内部函数可以访问外部函数的局部变量。这种能力使得闭包在许多场景下非常有用，例如函数工厂、私有变量的实现等。

在C# 中使用闭包 

using System;

// 定义一个Program类，主要用于演示闭包的概念
class Program
{
    // Main函数是程序的入口点
    static void Main()
    {
        // 定义一个外部变量，用于演示闭包能够访问外部变量的能力
        int outerVariable = 100;
        
        // 定义一个Action类型的委托，作为闭包，用于捕获并输出外部变量
        Action displayClosure = () =>
        {
            // 输出当前外部变量的值，展示闭包即使在定义后也能响应外部变量的变化
            Console.WriteLine($"外部变量： {outerVariable}");
        };

        // 调用闭包，根据当前outerVariable的值输出信息
        displayClosure(); // 输出 "外部变量: 100"

        // 修改外部变量的值，以展示闭包能够响应外部变量的变化
        outerVariable = 200;

        // 再次调用闭包，根据更新后的outerVariable的值输出信息
        displayClosure(); // 输出 "外部变量: 200"
    }
}

闭包的工作原理：

1. 捕获外部变量： 当定义闭包时，它会捕获其周围作用域中的变量（如 outerVariable），并保存对这些变量的引用。
2. 保持引用： 即使在定义闭包之后，外部变量的值发生了变化，闭包仍然可以使用和更新它们的最新值。这是因为闭包实际上持有对外部变量的引用，而不是简单地复制它们的值。
3. 动态更新： 因此，闭包展示了一种能力，即在其定义时捕获的变量可以根据其最新状态动态更新。这种特性对于需要延迟绑定或依赖外部环境变化的场景非常有用。

总结来说，闭包使得函数不仅仅是简单的执行代码块，还能够“记住”并操作其创建时所处环境的状态，

闭包的原理

词法闭包（Lexical closure）这个概念强调了函数在定义时捕获（绑定）了其周围环境的变量状态，并且在执行时可以访问和操作这些变量。

头等函数

头等函数( First Class)意味着语言将其视为第一类数据类型的函数, 意味着可以将函数分配给一个变量(或作为参数传递），然后像正常函数一样调用。

很明显，在C#中常使用的匿名函数、lambda表达式都是头等函数。

Func<int, int> MultiplyBy(int multiplier)
{
    return (x) => x * multiplier;
}

var multiplyBy5 = MultiplyBy(5);
Console.WriteLine(multiplyBy5(3)); // 输出 15

自由变量

在编程中，自由变量（Free variables）指的是在某个函数内部引用但并非由该函数直接定义的变量。这些变量可以在函数被定义的地方（即词法作用域）之外定义。当一个函数（通常是一个匿名函数或lambda表达式）引用了自由变量时，它会捕获该变量的当前状态，形成一个闭包（Closure）。这意味着即使定义这个函数的作用域不再存在，这些捕获的变量仍然可以被函数引用。

在 C# 中，lambda 表达式可以捕获周围的自由变量。例如，考虑以下代码片段：

int y = 5;

Func<int, int> addY = (x) => x + y;

Console.WriteLine(addY(10)); // 输出 15

在这里，lambda 表达式 (x) => x + y 捕获了外部作用域中的变量 y。即使定义 addY 的作用域已经结束，lambda 表达式依然可以访问和使用 y 的值。

这种捕获自由变量的机制使得 C# 中的闭包变得非常有用，特别是在需要延迟执行或者在异步编程中使用时。

闭包结合线程

闭包和线程结合，在编程中通常涉及到多线程编程的情况，特别是在需要共享状态或者传递函数时尤为常见。闭包可以用来捕获外部作用域的变量，并且在多线程环境中，这些捕获的变量能够被多个线程共享和访问，从而实现更灵活和高效的程序。

using System;
using System.Threading;

class Program
{
    // 主程序入口
    static void Main()
    {
        int counter = 0; // 初始化计数器变量

        // 创建第一个线程，用于增加计数器的值
        Thread thread = new Thread(() =>
        {
            // 线程A的执行逻辑：增加计数器的值并输出
            for (int i = 0; i < 10; i++)
            {
                counter++; // 增加计数器的值
                Console.WriteLine($"线程A：计数器 = {counter}");
                Thread.Sleep(100); // 暂停100毫秒
            }
        });

        thread.Start(); // 启动线程A

        // 创建第二个线程，用于减少计数器的值
        Thread threadB = new Thread(() =>
        {
            // 线程B的执行逻辑：减少计数器的值并输出
            for (int i = 0; i < 10; i++)
            {
                counter--; // 减少计数器的值
                Console.WriteLine($"线程B：计数器= {counter}");
                Thread.Sleep(150); // 暂停150毫秒
            }
        });

        threadB.Start(); // 启动线程B

        thread.Join(); // 等待线程A结束
        threadB.Join(); // 等待线程B结束

        Console.WriteLine("主线程正在退出。"); // 输出主线程结束的信息
    }
}

在这个例子中，我们定义了一个名为 counter 的外部变量，并在两个不同的线程中使用闭包来增加或减少它的值。这些线程在运行时捕获了外部作用域中的 counter 变量，并对其进行修改。通过使用闭包，每个线程可以独立地访问和修改 counter 的值，而无需直接传递或共享其他同步机制（如锁）。

注意事项

• 线程安全性： 在多线程环境中使用闭包要格外小心，确保被捕获的变量在多个线程间安全地使用和修改。在示例中，没有显式使用锁或其他线程同步机制，这可能会导致竞态条件或不一致的结果。
• 性能考虑： 虽然闭包提供了方便的访问外部变量的方式，但它可能会引入一些性能开销，特别是在频繁访问和修改变量时。因此，在高性能要求的应用中，应评估闭包的使用情况。
• 作用域管理： 确保理解闭包捕获的是变量的当前状态，而不是变量的引用。这意味着即使变量的作用域已经结束，闭包仍然可以访问和修改这些变量的值。

总结

闭包是指在程序运行时能够记住并访问定义时的外部作用域中变量的函数。它具备两个核心特征：能作为第一类对象传递（头等函数）和能捕获自由变量。头等函数意味着函数可以作为参数传递给其他函数，也可以作为返回值。自由变量是指在闭包函数内部引用但是不在函数内定义的变量。

闭包和委托机制不仅存在于 C# 中，许多现代编程语言都采用类似的设计来实现闭包功能。这种设计不仅仅帮助解决编程语言之间的语法差异，更重要的是提供了一种灵活和强大的编程工具，用于处理复杂的数据和控制流需求。