首页 > 代码库 > 理解C#中的闭包

理解C#中的闭包

2024-07-02 04:11:30   226人阅读

闭包的概念

内层的函数可以引用包含在它外层的函数的变量，即使外层函数的执行已经终止。但该变量提供的值并非变量创建时的值，而是在父函数范围内的最终值。

闭包的优点

使用闭包，我们可以轻松的访问外层函数定义的变量，这在匿名方法中普遍使用。比如有如下场景，在winform应用程序中，我们希望做这么一个效果，当用户关闭窗体时，给用户一个提示框。我们将添加如下代码：

private void Form1_Load(object sender, EventArgs e)
{
       string tipWords = "您将关闭当前对话框";
       this.FormClosing += delegate
       {
            MessageBox.Show(tipWords);
       };
}

若不使用匿名函数，我们就需要使用其他方式来将tipWords变量的值传递给FormClosing注册的处理函数，这就增加了不必要的工作量。

闭包陷阱

应用闭包，我们要注意一个陷阱。比如有一个用户信息的数组，我们需要遍历每一个用户，对各个用户做处理后输出用户名。

public class UserModel
{
        public string UserName
        {
            get;
            set;
        }

        public int UserAge
        {
            get;
            set;
        }
}
List<UserModel> userList = new List<UserModel>
            {
                new UserModel{ UserName="jiejiep", UserAge = 26},
                new UserModel{ UserName="xiaoyi", UserAge = 25},
                new UserModel{ UserName="zhangzetian", UserAge=24}
            };

            foreach (var u in userList)
            {
                ThreadPool.QueueUserWorkItem((obj) =>
                {
                    //TODO
                    //Do some process...
                    //...
                    Thread.Sleep(1000);
　　　　　　　　　　　 MessageBox.Show(u.UserName);
                });
            }

我们预期的输出是， jiejiep, xiaoyi, zhangzetian

但是实际我们运行后发现，输出了3次 zhangzetian.

为什么没有达到我们预期的效果呢？让我们再来看一下闭包的概念。内层函数引用的外层函数的变量的最终值。就是说，当线程中执行方法时，方法中的u参数的值，始终是foreach遍历的最后一个元素。原来如此，那我们该如何避免闭包陷阱呢？C#中普遍的做法是，将匿名函数引用的变量用一个临时变量保存下来，然后在匿名函数中使用临时变量。

foreach (var u in userList)
            {
                UserModel tempUser = u;
                ThreadPool.QueueUserWorkItem((obj) =>
                {
                    //TODO
                    //Do some process...
                    //...
                    Thread.Sleep(1000); 
　　　　　　　　　　　 MessageBox.Show(tempUser.UserName);
                });
            }

我们再运行来看，输出依次为 jiejiep,xiaoyi, zhangzetian

NET编译器与闭包

提出了问题，给出了解决方案，我们总算知道该怎么正确使用闭包了。但是dotNET是如何实现闭包的呢？执着的程序猿们，不会满足于这种表象的解决方案，让我们来看看dotNET是如何实现闭包的。我们可以微软提供的isdasm.exe来查看编译后的代码。我们先来看看有问题的代码。将IL代码翻译后，可以得到如下的伪代码。

    public class TempClass
    {
        public UserModel um
        {
            get;
            set;
        }

        public void ShowMessage(object obj)
        {
            Thread.Sleep(1000);
            MessageBox.Show(um.UserName);
        }
    }
        TempClass tempCls = new TempClass();
        foreach (var u in userList)
        {
             tempCls.um = u;

             ThreadPool.QueueUserWorkItem((obj) =>
             {
                tempCls.ShowMessage(obj);
             });
        }

原来，编译器为我们生成了一个临时类，该类包含一个 UserModel成员um， 一个实例方法 ShowMessage(object) 。再看看遍历部分的代码，我们顿时就豁然开朗了，原来一直都只有一个 TempClass实例，遍历时始终改变的是tempCls对象的um字段的值。所以最后输出的，始终是最后一个遍历得到的元素的 UserName 。

我们再来看看使用临时变量后的代码，编译器是如何处理的呢。

foreach (var u in userList)
{
    TempClass tempCls = new TempClass();
    tempCls.um = u;

    ThreadPool.QueueUserWorkItem((obj) =>
    {
         tempCls.ShowMessage(obj);
    });
}

我们看到，使用临时变量这种解决方案时，编译器相当于是每次遍历时都实例化了一个 TempClass对象。所以内层函数引用的tempCls的um成员始终是遍历对应的元素。故能有效的解决闭包带来的陷阱。


联系
我们