闭包的详细认识与实例


    参考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> 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;
                         };

闭包的详细认识与实例_第1张图片


            构造一个类,字段为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 callback)
        {
            int a = 10 + 20;
            callback(a);//闭包使用上面a值
        }


        上面ProcessData 方法接受一个 Action 类型的回调函数作为参数。在 Main 方法中,用lambda将这个方法传过去以便闭包中使用,闭包并没有改变a的值,它只是引用了一下。    2. 保存状态:
        闭包可以用于保存状态,以便在稍后的调用中使用。

        public Func 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}...");
            });
        }  

 

闭包的详细认识与实例_第2张图片


        
        如果改为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,它们的值都不相同,因此输出的结果也会不同。
    
 

你可能感兴趣的:(C#问题集,C#,闭包,临时变量,回调函数)