最近在学习golang的时候发现一件有趣的事情，go有一个闭包的概念，于是我对比了一下C#的"闭包"...

• golang的闭包

calc 是一个接收一个形参a、两个函数返回值的函数，两个函数返回值是指这一段代码：(func(int) int, func(int) int)，go语言支持多个返回值
main 函数，所有语言一样程序的入口
【1】 通过main函数调用calc函数执行返回两个函数，分别是f1和f2，同时会打印一边参数a的内存地址
【2】 调用f1函数和f2函数，打印一遍add和sub里面"引用"calc函数参数a的内存地址，并返回calc参数a+=i和a-=i的结果
【3】 输出f1函数和f2函数执行返回的结果 

 1 func calc(a int) (func(int) int, func(int) int) {
 2     //打印变量地址
 3     fmt.Println(&a)
 4 
 5     //创建a+=add函数入参i，并返回的a的结果的函数，并返回给调用者
 6     add := func(i int) int {
 7         //返回值函数内部打印一遍变量地址，测试这里面的a和calc的a内存地址是否一致
 8         fmt.Println(&a)
 9         a += i
10         return a
11     }
12     //创建a-=sub函数入参i，并返回的a的结果的函数，并返回给调用者
13     sub := func(i int) int {
14         fmt.Println(&a)
15         a -= i
16         return a
17     }
18     //返回两个函数
19     return add, sub
20 }
21 
22 func main() {
23     //f1对应add f2对应sub
24     f1, f2 := calc(10)
25     //调用f1和f2函数，同时打印f1 f2返回结果
26     fmt.Println(f1(1), f2(2)) //11 9
27     fmt.Println(f1(3), f2(4)) //12 8
28     fmt.Println(f1(5), f2(6)) //13 7
29 }

 打印结果：

0xc00000a0a8　　　　　　调用calc函数所打印 fmt.Println(&a) 的结果

0xc00000a0a8　　　　　　调用f1(1) add里面的 fmt.Println(&a) 
0xc00000a0a8　　　　　　调用f2(2) sub里面的 fmt.Println(&a) 
11 9　　　　　　　　　　　f1(1)和f2(2) 返回值

0xc00000a0a8　　　　　　调用f1(3) 
0xc00000a0a8　　　　　　调用f1(4) 
12 8　　　　　　　　　　　f1(3)和f2(4) 返回值

0xc00000a0a8　　　　　　调用f1(5) 
0xc00000a0a8　　　　　　调用f1(6) 
13 7　　　　　　　　　　　f1(5)和f2(6) 返回值

是不是很惊讶，calc函数参数a这个值变量变成了引用关系，在calc函数执行完之后并没有释放，并供给add和sub使用，这就是go的闭包。

• C#的"闭包"

 通过下面代码能“实现”上面golang的闭包

 1 public void Calc(int a, out Func<int, int> add, out Func<int, int> sub)
 2 {
 3     add = (int i) =>
 4     {
 5         return a += i;
 6     };
 7 
 8     sub = (int i) =>
 9     {
10         return a -= i;
11     };
12 }
13 
14 public void Show()
15 {
16     Func<int, int> f1;
17     Func<int, int> f2;
18     this.Calc(10, out f1, out f2);
19 
20     Console.WriteLine(string.Format("{0}  {1}", f1(1), f2(2)));
21     Console.WriteLine(string.Format("{0}  {1}", f1(3), f2(4)));
22     Console.WriteLine(string.Format("{0}  {1}", f1(5), f2(6)));
23 }

 返回值打印结果：

11 9
12 8
13 7

得出结论确实是能实现和golang上面代码一样的功能，calc函数参数a变量变成"引用"关系，提供给add和sub使用。

但是...我将代码改了下

 1 public class TestFunc
 2 {
 3     //存储内存地址的字典，供后续查看
 4     private unsafe Dictionary<string, int*[]> PADic = new Dictionary<string, int*[]>();
 5 
 6     public void Calc(int a, out Func<int, int> add, out Func<int, int> sub)
 7     {
 8         //运行执行不安全的代码
 9         unsafe
10         {
11             //取a的内存地址
12             int* aa = (int*)a;
13             //将内存地址存储到字典中
14             this.PADic.Add("Calc(a)：", new int*[] { aa });
15         }
16 
17         add = (int i) =>
18         {
19             unsafe
20             {
21                 int* aa = (int*)a;
22                 this.PADic.Add(string.Format("f1({0})：", i), new int*[] { aa });
23             }
24             return a += i;
25         };
26 
27         sub = (int i) =>
28         {
29             unsafe
30             {
31                 int* aa = (int*)a;
32                 this.PADic.Add(string.Format("f2({0})：", i), new int*[] { aa });
33             }
34             return a -= i;
35         };
36     }
37 
38     public void Show()
39     {
40         Func<int, int> f1;
41         Func<int, int> f2;
42         this.Calc(10, out f1, out f2);
43         Console.WriteLine(string.Format("{0}  {1}", f1(1), f2(2))); // 11 9
44         Console.WriteLine(string.Format("{0}  {1}", f1(3), f2(4))); // 12 8
45         Console.WriteLine(string.Format("{0}  {1}", f1(5), f2(6))); // 13 7
46     }
47 }

 （指针地址没办法输出，直接调试看变量内容）输出结果：

通过上面代码可以看出，每次调用f1和f2的时候，所"引用"的参数a是“值复制”的，而不是引用，因为它们的内存地址是有变化。

得出结论，功能虽然都能实现，但是有本质区别的。