脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → C#教程 → C#函数和闭包

C#中函数的创建和闭包的理解

 更新时间：2015年04月10日 08:49:21   投稿：junjie  
这篇文章主要介绍了C#中函数的创建和闭包的理解,本文讲解了动态创建函数、匿名函数不足之处、理解c#中的闭包、闭包的优点等内容,需要的朋友可以参考下

动态创建函数

大多数同学，都或多或少的使用过。回顾下c#中动态创建函数的进化：

C# 1.0中：

复制代码 代码如下:

public delegate string DynamicFunction(string name);
  public static DynamicFunction GetDynamicFunction()
  {
      return GetName;
  }
  static string GetName(string name)
  {
      return name;
  }
  var result = GetDynamicFunction()("mushroom");

3.0写惯了是不是看起来很繁琐、落后。 刚学委托时，都把委托理解成函数指针，也来看下用函数指针实现的：

复制代码 代码如下:

char GetName(char p);
typedef char (*DynamicFunction)(char p);
DynamicFunction GetDynamicFunction()
{
    return GetName;
}
char GetName(char p)
{
    return p;
};
char result = GetDynamicFunction()('m');

对比起来和c# 1.0几乎一模一样了(引用/指针差别)，毕竟是同一家族的。

C# 2.0中，增加匿名函数：

复制代码 代码如下:

 public delegate string DynamicFunction(string name);
      DynamicFunction result2 = delegate(string name)
      {
          return name;
      };

C# 3.0中，增加Lambda表达式，华丽的转身：

复制代码 代码如下:

 public static Func<string, string> GetDynamicFunction()
 {
        return name => name;
 }
 var result = GetDynamicFunction()("mushroom");

匿名函数不足之处
虽然增加Lambda表达式，已经极大简化了我们的工作量。但确实有些不足之处：

复制代码 代码如下:

var result = name => name;

这些写编译时是报错的。因为c#本身强类型语言的，提供var语法糖只是为了省去声明确定类型的工作量。 编译器在编译时必须能够完全推断出各参数的类型才行。代码中的name参数类型，显然在编译时无法推断出来的。
复制代码 代码如下:

var result = (string name) => name;
Func<string, string> result2 = (string name) => name;
Expression<Func<string, string>> result3 = (string name) => name;

上面直接声明name类型呢，很遗憾这样也是报错的。代码中已经给出答案了，编译器推断不出右边表达式是属于Func<string, string>类型还是Expression<Func<string, string>>类型。

复制代码 代码如下:

 dynamic result = name => name;
 dynamic result1 = (Func<string,string>)(name => name);

用dynamic呢，同样编译器也分不出右边是个委托，我们显示转换下就可以了。
复制代码 代码如下:

Func<string, string> function = name => name;
DynamicFunction df = function;

这里定义个func委托，虽然参数和返回值类型都和DynamicFunction委托一样，但编译时还是会报错：不能隐式转换Func<string, string>到DynamicFunction，2个类型是不兼容的。

理解c#中的闭包

谈论到动态创建函数，都要牵扯到闭包。闭包这个概念资料很多了，理论部分这里就不重复了。 来看看c#代码中闭包：

复制代码 代码如下:

Func<Func<int>> A = () =>
        {
            var age = 18;
            return () =>  //B函数
            {
                return age;
            };
        };
        var result = A()();

上面就是闭包，可理解为就是： 跨作用域访问函数内变量，也有说带着数据的行为。
C#变量作用域一共有三种，即：类变量，实例变量，函数内变量。子作用域访问父作用域的变量(即函数内访问实例/类变量)在我们看来理所当然的，也符合我们一直的编程习惯。
例子中匿名函数B是可以访问上层函数A的变量age。对于编译器而言，A函数是B函数的父作用域，所以B函数访问父作用域的age变量是符合规范的。

复制代码 代码如下:

int age = 16;
        void Display()
        {
            Console.WriteLine(age); 
            int age = 18;
            Console.WriteLine(age);
        }

上面编译会报错未声明使用，编译器检查到函数内声明age后，作用域就会覆盖父作用域的age，(像JS就undefined了)。

复制代码 代码如下:

        Func<int> C = () =>
         {
             var age = 19;
             return age;
         };

上面声明个同级函数C，那么A函数是无法访C函数中的age变量的。 简单来说就是不可跨作用域访问其他函数内的变量。 那编译器是怎么实现闭包机制的呢？

如上图，答案是升级作用域，把A函数升级为一个实例类作用域。 在编译代码期间，编译器检查到B函数使用A函数内变量时，会自动生成一个匿名类x，把原A函数内变量age提升为x类的字段(即实例变量)，A函数提升为匿名类x的实例函数。下面是编译器生成的代码(精简过)：

复制代码 代码如下:

class Program1
{
    static Func<Func<int>> CachedAnonymousMethodDelegate2;
    static void Main(string[] args)
    {
        Func<Func<int>> func = new Func<Func<int>>(Program1.B);
        int num = func()();
    }
    static Func<int> B()
    {
        DisplayClass cl = new DisplayClass();
        cl.age = 18;
        return new Func<int>(cl.A);
    }
}
sealed class DisplayClass
{
    public int age;
    public int A()
    {
        return this.age;
    }
}

我们再来看个复杂点的例子：

复制代码 代码如下:

static Func<int, int> GetClosureFunction()
    {
        int val = 10;
        Func<int, int> interAdd = x => x + val;
        Console.WriteLine(interAdd(10));
        val = 30;
        Console.WriteLine(interAdd(10));
        return interAdd;
    }
  Console.WriteLine(GetClosureFunction()(30));

输出结果是20、40、60。 当看到这个函数内变量val通过闭包被传递的时候，我们就知道val不仅仅是个函数内变量了。之前我们分析过编译器怎么生成的代码，知道val此时是一个匿名类的实例变量，interAdd是匿名类的实例函数。所以无论val传递多少层，它的值始终保持着，直到离开这个(链式)作用域。

关于闭包，在js当中谈论的比较多，同理，可以对比理解下：

复制代码 代码如下:

function A() {
    var age = 18;
    return function () {
        return age;
    }
}
A()();

闭包的优点

1.对变量的保护。想暴露一个变量值，但又怕声明类或实例变量会被其他函数污染，这时就可以设计个闭包，只能通过函数调用来使用它。
2.逻辑连续性和变量保持。 A()是执行一部分逻辑，A()()仅接着A()逻辑继续走下去，在这个逻辑上下文期间，变量始终都被保持着，可以随意使用。

您可能感兴趣的文章:

相关文章

  • C# Winform 实现屏蔽键盘的win和alt+F4的实现代码

    C# Winform 实现屏蔽键盘的win和alt+F4的实现代码

    最近在做一个恶搞程序，就是打开后，程序获得桌面的截图然后，然后全屏显示在屏幕上，用户此时则不能进行任何操作。
    2009-02-02
  • C# FileSystemWatcher 在监控文件夹和文件时的使用方法

    C# FileSystemWatcher 在监控文件夹和文件时的使用方法

    这篇文章主要介绍了C# FileSystemWatcher 在监控文件夹和文件时的使用方法，文中讲解非常细致，代码帮助大家更好的理解和学习，感兴趣的朋友可以参考下
    2020-06-06
  • c#获取存储过程返回值示例分享

    c#获取存储过程返回值示例分享

    这篇文章主要介绍了C#获取存储过程返回值的方法，大家参考使用吧
    2014-01-01
  • C# xmlSerializer简单用法示例

    C# xmlSerializer简单用法示例

    这篇文章主要介绍了C# xmlSerializer简单用法,结合实例形式分析了C#基于xmlSerializer操作xml的读取、输出等相关操作技巧,需要的朋友可以参考下
    2017-08-08
  • C#调用VB进行简繁转换的方法

    C#调用VB进行简繁转换的方法

    这篇文章主要介绍了C#调用VB进行简繁转换的方法,通过调用VB的动态链接库实现繁简转换的技巧,非常具有实用价值,需要的朋友可以参考下
    2015-02-02
  • C#操作excel打印的示例

    C#操作excel打印的示例

    这篇文章主要介绍了C#操作excel打印的示例，帮助大家利用c#打印表格，提高办公效率，感兴趣的朋友可以了解下
    2020-10-10
  • C#、vb.net及SQL判断指定年份是否为闰年的方法

    C#、vb.net及SQL判断指定年份是否为闰年的方法

    这篇文章主要介绍了C#、vb.net及SQL判断指定年份是否为闰年的方法,分别以三种方法实现了判断闰年的功能,在进行项目开发中具有一定的参考借鉴价值,需要的朋友可以参考下
    2014-11-11
  • C# 设计模式系列教程-抽象工厂模式

    C# 设计模式系列教程-抽象工厂模式

    抽象工厂模式为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。
    2016-06-06
  • C# WebApi 接口传参详解

    C# WebApi 接口传参详解

    这篇文章主要介绍了C# WebApi 接口传参详解，本篇打算通过get、post、put、delete四种请求方式分别谈谈基础类型（包括int/string/datetime等）、实体、数组等类型的参数如何传递。感兴趣的小伙伴们可以参考一下
    2018-07-07
  • c#中SqlHelper封装SqlDataReader的方法

    c#中SqlHelper封装SqlDataReader的方法

    这篇文章主要介绍了c#中SqlHelper封装SqlDataReader的方法,涉及C#针对数据库相关操作封装与使用的技巧,需要的朋友可以参考下
    2015-05-05

最新评论