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

首先,还是看一个例子:

 1   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
12            Console.ReadLine();
13        }
14    }
15
16    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看看: 

1public 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
9

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

1public void SayHello([System.Runtime.InteropServices.Optional][System.Runtime.InteropServices.DefaultParameterValue("fanweixiao")] string name)
2{
3    Console.Write(name);
4}

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

 1.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
 8    .method public hidebysig instance void Do1(int32 a, string b) cil managed
 9    {
10    }
11
12    .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(调用者)所越权操作,剥夺起政治权利终身的. 所以这个可选参数特性的关键点在于调用的时候编译器做了什么. 看实际调用的情况:

 1private 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: 

 1.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应该输出什么值也就很清楚了吧:

 1static void Main(string[] args)
 2{
 3    int i = 0;
 4    Do(i: i++, k: i++, j: i++);
 5    Console.ReadLine();
 6}
 7
 8static void Do(int i = 0, int j = 0, int k = 0)
 9{
10    Console.WriteLine(string.Format("{0} -> {1} -> {2}", i, j, k)); 
11}

没错, 应该显示0,2,1

更详细的关于这里CLI的解释可以参考这篇blog.
其他C#4.0新特性的文章:
C#4.0新特性之二:Named and Optional Parameters (1)
c#4.0新特性之一: Dynamic Lookup (2)
 

c#4.0新特性之一: Dynamic Lookup (1)