Agora que o C # suporta parâmetros nomeados, eu estava verificando se foi implementado da mesma maneira que o VB o fez e descobri que há uma pequena diferença. Tomemos, por exemplo, uma função de biblioteca como esta:

public static void Foo(string a, string b)
{
    Console.WriteLine(string.Format("a: {0}, b: {1}", a, b));
}

Em C #, se você chamar assim:

Foo(a: "a", b: "b");

O compilador produz as seguintes instruções de IL:

.locals init (
    [0] string CSAgora que o C # suporta parâmetros nomeados, eu estava verificando se foi implementado da mesma maneira que o VB o fez e descobri que há uma pequena diferença. Tomemos, por exemplo, uma função de biblioteca como esta:0000,
    [1] string CSAgora que o C # suporta parâmetros nomeados, eu estava verificando se foi implementado da mesma maneira que o VB o fez e descobri que há uma pequena diferença. Tomemos, por exemplo, uma função de biblioteca como esta:0001)
L_0000: nop 
L_0001: ldstr "a"
L_0006: stloc.0 
L_0007: ldstr "b"
L_000c: stloc.1 
L_000d: ldloc.0 
L_000e: ldloc.1 
L_000f: call void [TestLibrary]TestLibrary.Test::Foo(string, string)
L_0014: nop 
L_0015: ret 

Que se traduz no seguinte código C #:

string CSAgora que o C # suporta parâmetros nomeados, eu estava verificando se foi implementado da mesma maneira que o VB o fez e descobri que há uma pequena diferença. Tomemos, por exemplo, uma função de biblioteca como esta:0000 = "a";
string CSAgora que o C # suporta parâmetros nomeados, eu estava verificando se foi implementado da mesma maneira que o VB o fez e descobri que há uma pequena diferença. Tomemos, por exemplo, uma função de biblioteca como esta:0001 = "b";
Test.Foo(CSAgora que o C # suporta parâmetros nomeados, eu estava verificando se foi implementado da mesma maneira que o VB o fez e descobri que há uma pequena diferença. Tomemos, por exemplo, uma função de biblioteca como esta:0000, CSAgora que o C # suporta parâmetros nomeados, eu estava verificando se foi implementado da mesma maneira que o VB o fez e descobri que há uma pequena diferença. Tomemos, por exemplo, uma função de biblioteca como esta:0001);

No VB, se você chamar assim:

Foo(a:="a", b:="b")

O compilador produz as seguintes instruções de IL:

L_0000: nop 
L_0001: ldstr "a"
L_0006: ldstr "b"
L_000b: call void [TestLibrary]TestLibrary.Test::Foo(string, string)
L_0010: nop 
L_0011: nop 
L_0012: ret 

Que se traduz no seguinte código VB:

Foo("a", "b");

A maneira como o VB exige muito menos chamadas de instrução, então há alguma vantagem na maneira como o C # a implementa? Se você não usar os parâmetros nomeados, o C # produzirá o mesmo que o VB.

EDITAR: Agora que determinamos que as instruções extras desaparecem no modo de lançamento, existe uma razão específica para elas estarem presentes no modo de depuração? O VB age da mesma maneira nos dois modos, e o C # não insere as instruções extras ao chamar o método normalmente sem parâmetros nomeados (inclusive quando você usa parâmetros opcionais).