C#4.0新特性之二:Named and Optional Parameters (2) 剖析篇

在上一篇介绍该特性的文章里, 大家都在说这是vb里已经有的东西. 切不管c#的发展方向, 我们剖析一下这个特性的实现原理:

首先,还是看一个例子:

class Program
2

{
3

static void Main(string[] args)
4

{
5

var foo1 = new Foo();
6

foo1.Do1(1,"fan");
7

foo1.Do2(2,"onlyvc");
8

foo1.Do2(3);
9

foo1.Do2(b : "only");
10

foo1.Do2(b: "only", a: 2);
11

Console.ReadLine();
13

}
14

}
15

public class Foo
17

{
18

public void Do1(int a, string b) { Console.WriteLine(a.ToString()+b+"\n"); }
19

public void Do2(int a=0, string b="fanweixiao") { Console.WriteLine(a.ToString()+b+"\n"); }
20

}

看过上一篇文章的朋友肯定知道答案是什么了, 用Reflector看看:

public class Foo
2

{
3

// Methods
4

public Foo();
5

public void Do1(int a, string b);
6

public void Do2([Optional, DefaultParameterValue(0)] int a, [Optional, DefaultParameterValue("fanweixiao")] string b);
7

}
8

对于Do2()的方法的定义增加了两个attribute: Optional和DefaultParameterValue. 这不是新东西, 我们在2.0时代就可以定义这样的方法:

public void SayHello([System.Runtime.InteropServices.Optional][System.Runtime.InteropServices.DefaultParameterValue("fanweixiao")] string name)
2

{
3

Console.Write(name);
4

}

只是在c#里调用SayHello()这个函数是必须把参数都写全的. 那么接下来我们看看IL的样子:

.class public auto ansi beforefieldinit Foo
2

extends [mscorlib]System.Object
3

{
4

.method public hidebysig specialname rtspecialname instance void .ctor() cil managed
5

{
6

}
7

.method public hidebysig instance void Do1(int32 a, string b) cil managed
9

{
10

}
11

.method public hidebysig instance void Do2([opt] int32 a, [opt] string b) cil managed
13

{
14

.param [1] = int32(0)
15

.param [2] = string('fanweixiao')
16

}
17

}

Do2()这个方法里有两个特殊的东西: opt和.param, 在CLI Spec文档里就有这两个东东的详细说明, 简要来说,有了opt修饰的参数,那么他就是可选的,所有opt修饰的参数要用.param指定类型和默认值,注意这里.param[]的下标是从1开始的,.param[0] 表示的是函数返回值. 而这个.param指定的参数其实是常量值constant value, 只所以能够变化是因为在编译期间这个值是可以被callsite(调用者)所越权操作,剥夺起政治权利终身的. 所以这个可选参数特性的关键点在于调用的时候编译器做了什么. 看实际调用的情况:

private static void Main(string[] args)
2

{
3

Foo foo1 = new Foo();
4

foo1.Do1(1, "fan");
5

foo1.Do2(2, "onlyvc");
6

foo1.Do2(3, "fanweixiao");
7

string CS$0$0000 = "only";
8

foo1.Do2(0, CS$0$0000);
9

    CS$0$0000 = "only";
10    int CS$0$0001 = 2;
11    foo1.Do2(CS$0$0001, CS$0$0000);
12

Console.ReadLine();
13

}

其实这是编译时就确定了要传递的参数的值了, 默认值被编译器从方法里"提取"了出来. 再看IL:

.method private hidebysig static void Main(string[] args) cil managed
2

{
3

.entrypoint
4

.maxstack 3
5

.locals init (
6

[0] class LearnCSharp4.Foo foo1,
7

[1] string CS$0$0000,
8

[2] int32 CS$0$0001)
9

L_0000: nop
10

L_0001: newobj instance void LearnCSharp4.Foo::.ctor()
11

L_0006: stloc.0
12

L_0007: ldloc.0
13

L_0008: ldc.i4.1
14

L_0009: ldstr "fan"
15

L_000e: callvirt instance void LearnCSharp4.Foo::Do1(int32, string)
16

L_0013: nop
17

L_0014: ldloc.0
18

L_0015: ldc.i4.2
19

L_0016: ldstr "onlyvc"
20

L_001b: callvirt instance void LearnCSharp4.Foo::Do2(int32, string)
21

L_0020: nop
22

L_0021: ldloc.0
23

L_0022: ldc.i4.3
24

L_0023: ldstr "fanweixiao"
25

L_0028: callvirt instance void LearnCSharp4.Foo::Do2(int32, string)
26

L_002d: nop
27

L_002e: ldloc.0
28

L_002f: ldstr "only"
29

L_0034: stloc.1
30

L_0035: ldc.i4.0
31

L_0036: ldloc.1
32

L_0037: callvirt instance void LearnCSharp4.Foo::Do2(int32, string)
33

    L_003c: nop
34    L_003d: ldloc.0
35    L_003e: ldstr "only"
36    L_0043: stloc.1
37    L_0044: ldc.i4.2
38    L_0045: stloc.2
39    L_0046: ldloc.2
40    L_0047: ldloc.1
41    L_0048: callvirt instance void LearnCSharp4.Foo::Do2(int32, string)
42    L_004d: nop
43

L_004e: call string [mscorlib]System.Console::ReadLine()
44

L_0053: pop
45

L_0054: ret
46

}

我们看大字体的部分, stloc(存东西到变量)的顺序是先1后2, 很明显是先存放了string然后存int的值,这跟我们写的调用的参数(b:"only",a:2)是一致的,然后在L_0046和L_0047这两句里颠倒了ldloc(从变量里读东西)的顺序, 所以这样就能正常的调用Do2(int32, string)这个函数了.

原理清楚了, 那么下面这个demo应该输出什么值也就很清楚了吧:

static void Main(string[] args)
2

{
3

int i = 0;
4

Do(i: i++, k: i++, j: i++);
5

Console.ReadLine();
6

}
7