Question

阅读Jon Skeet一书，我发现（现在已经有一段时间）在函数调用中使用了“命名参数”。这是一个快速简单的例子：

void Dump(int x, int y, int z, string cSomeText)
{
    // no use, just to see how we call this later
    string cOnMe = string.Format("[{0}] [{1}] [{2}] [{3}]", x, y, z, cSomeText);
}

void CallDumpWithoutNameArguments()
{
    // call with out Name Arguments
    Dump(1, 2, 3, "Test string");
}

void CallDumpWithNameArguments()
{ 
    // more easy to read, call the same function with Name Arguments
    Dump(x: 1, y: 2, z: 3, cSomeText: "Test string");
}

使用它之后看到编译后的代码，我看到在调用函数之前使用这个名字实际上是创建了变量。

这是创建的代码：

private void CallDumpWithoutNameArguments()
{
    this.Dump(1, 2, 3, "Test string");
}

private void CallDumpWithNameArguments()
{
    int CS$0$0000 = 1;
    int CS$0$0001 = 2;
    int CS$0$0002 = 3;
    string CS$0$0003 = "Test string";
    this.Dump(CS$0$0000, CS$0$0001, CS$0$0002, CS$0$0003);
}

和完整编译的代码，你看我用“命名参数”调用它有多大

  .method private hidebysig instance void CallDumpWithoutNameArguments()
  {
    .maxstack 8
                nop
                ldarg.0
                ldc.i4.1
                ldc.i4.2
                ldc.i4.3
                ldstr    "Test string"
                call     instance void SubSonic.BabisExtrasNoUseIt.ExtraTestCode::Dump(int32 x, int32 y, int32 z, string cSomeText)
                nop
                ret
  }

  .method private hidebysig instance void CallDumpWithNameArguments()
  {
    .maxstack 5
    .locals init (int32 V0,
                  int32 V1,
                  int32 V2,
                  string V3)
                nop
                ldarg.0
                ldc.i4.1
                stloc.0
                ldc.i4.2
                stloc.1
                ldc.i4.3
                stloc.2
                ldstr    "Test string"
                stloc.3
                ldloc.0
                ldloc.1
                ldloc.2
                ldloc.3
                call     instance void SubSonic.BabisExtrasNoUseIt.ExtraTestCode::Dump(int32 x, int32 y, int32 z, string cSomeText)
                nop
                ret
  }

所以这是c＃忘记优化的一点，还是有其他用途？

跟进

我想清楚上面的代码是编译生成的代码。以下是我从Servy得到的答案。

private void CallDumpWithoutNameArguments()
{
    // what generated from
    // int i = 0;
    // Dump(i++, i++, i++, cSomeText: "Test string");

    int i = 0;
    string CS$0$0000 = "Test string";
    this.Dump(i++, i++, i++, CS$0$0000);
} 

private void CallDumpWithNameArguments()
{
    // what is generate from
    // int i = 0;
    // Dump(x: i++, z: i++, y: i++, cSomeText: "Test string");

    int i = 0;
    int CS$0$0000 = i++;
    int CS$0$0001 = i++;
    int CS$0$0002 = i++;
    string CS$0$0003 = "Test string";
    this.Dump(CS$0$0000, CS$0$0002, CS$0$0001, CS$0$0003);
}

Answer 1

这与确保代码以正确的顺序运行有关。对于命名参数，每个参数的表达式需要按照它们在源代码中出现的顺序执行，而不是它们出现在定义的实际参数列表中的顺序。想象一下（非常卑鄙）的电话：

int i = 0;
Dump(x: i++,  z: i++, y: i++, cSomeText: "Test string");

最终应该与：

相同

Dump(0, 1, 2, "Test string");

或

Dump(0, 2, 1, "Test string");

如果您没有为每个命名参数设置局部变量，那么最终会得到第一个变量，如果这样做，最终会得到第二个。

看起来似乎不是试图确定是否有必要制作局部变量（这些参数是乱序的，它们是否会引起副作用，这些副作用是否可见于其他参数中的表达式）只是总是创建局部变量更简单。已经多次声明C＃编译器将确保优化的正确性;它为JIT留下了优化。

为什么在函数中使用名称参数实际上会生成更多代码？

跟进

1 个答案: