Is there an additional runtime cost for using named parameters?

Consider the following struct:

    public struct vip
    {
        string email;
        string name;
        int category;

        public vip(string email, int category, string name = "")
        {
            this.email = email;
            this.name = name;
            this.category = category;
        }
    }

Is there a performance difference between the following two 开发者_开发知识库calls?

var e = new vip(email: "foo", name: "bar", category: 32);

var e = new vip("foo", 32, "bar");

Is there a difference if there are no optional parameters defined?

I believe none. It's only a language/compiler feature, call it syntactic sugar if you like. The generated CLR code should be the same.

There's a compile-time cost, but not a runtime one...and the compile time is very, very minute.

Like extension methods or auto-implemented properties, this is just magic the compiler does, but in reality generates the same IL we're all familiar with and have been using for years.

Think about it this way, if you're using all the parameters, the compiler would call the method using all of them, if not, it would generate something like this behind the scenes:

 var e = new vip(email: "foo", category: 32); //calling

 //generated, this is what it's actually saving you from writing
 public vip(string email, int category) : this(email, category, "bar") { }

No it is a compile-time feature only. If you inspect the generated IL you'll see no sign of the named parameters. Likewise, optional parameters is also a compile-time feature.

One thing to keep in mind regarding named parameters is that the names are now part of the signature for calling a method (if used obviously) at compile time. I.e. if names change the calling code must be changed as well if you recompile. A deployed assembly, on the other hand, will not be affected until recompiled, as the names are not present in the IL.

There shouldn't be any. Basically, named parameters and optional parameters are syntactic sugar; the compiler writes the actual values or the default values directly into the call site.

EDIT: Note that because they are a compiler feature, this means that changes to the parameters only get updated if you recompile the "clients". So if you change the default value of an optional parameter, for example, you will need to recompile all "clients", or else they will use the old default value.

Actually, there is cost at x64 CLR

Look at here http://www.dotnetperls.com/named-parameters

I am able to reproduce the result: named call takes 4.43 ns, and normal call takes 3.48 ns (program runs in x64)

However, in x86, both take around 0.32 ns

The code is attached below, compile and run it yourself to see the difference.

Note that in VS2012 the default targat is AnyCPU x86 prefered, you have to switch to x64 to see the difference.

using System;
using System.Diagnostics;

class Program
{
    const int _max = 100000000;
    static void Main()
    {
    Method1();
    Method2();

    var s1 = Stopwatch.StartNew();
    for (int i = 0; i < _max; i++)
    {
        Method1();
    }
    s1.Stop();
    var s2 = Stopwatch.StartNew();
    for (int i = 0; i < _max; i++)
    {
        Method2();
    }
    s2.Stop();
    Console.WriteLine(((double)(s1.Elapsed.TotalMilliseconds * 1000 * 1000) /
        _max).ToString("0.00 ns"));
    Console.WriteLine(((double)(s2.Elapsed.TotalMilliseconds * 1000 * 1000) /
        _max).ToString("0.00 ns"));
    Console.Read();
    }

    static void Method1()
    {
    Method3(flag: true, size: 1, name: "Perl");
    }

    static void Method2()
    {
    Method3(1, "Perl", true);
    }

    static void Method3(int size, string name, bool flag)
    {
    if (!flag && size != -1 && name != null)
    {
        throw new Exception();
    }
    }
}