Can I pass arbitrary number of named parameters to function in C#?

Question

Is there some kind of equivalent of Python's **kwargs in C#? I would like to be able to pass variable number of named arguments into functon, then get them as something Dictionary-like inside function and cycle over them.

Answer 1

There is nothing in C# available to let you pass in arbitrary named parameters like this.

You can get close by adding a Dictionary<string, object> parameter, which lets you do something similar but requiring a constructor, the "parameter names" to be strings and some extra braces:

static void Method(int normalParam, Dictionary<string, object> kwargs = null)
{
   ...
}

Method(5, new Dictionary<String, object>{{ "One", 1 }, { "Two", 2 }});

You can get closer by using the ObjectToDictionaryRegistry here, which lets you pass in an anonymous object which doesn't require you to name a dictionary type, pass the parameter names as strings or add quite so many braces:

static void Method(int normalParam, object kwargs = null)
{
    Dictionary<string, object> args = ObjectToDictionaryRegistry(kwargs);
    ...
}

Method(5, new { One = 1, Two = 2 });

However, this involves dynamic code generation so will cost you in terms of performance.

In terms of syntax, I doubt you'll ever be able to get rid of the `new { ... }' wrapper this requires.

Answer 2

If you specifically want a series of KeyValuePairs instead of an array of values, you could do something like this:

public class Foo
{
    public Foo(params KeyValuePair<object, object>[] myArgs)
    {
        var argsDict = myArgs.ToDictionary(k=>k.Key, v=>v.Value);
        // do something with argsDict
    }
}

myArgs would be an array of KeyValuePair<object, object> that you can iterate or convert to a dictionary as shown above. Just a note though, the conversion to dictionary might fail if you pass multiple KeyValuePair<>s with the same key. You might have to do some checking ahead of time before converting to a dictionary.

You would call it like this:

KeyValuePair<object, object> myKvp1 = new KeyValuePair<object, object>(someKey1, someValue1);
KeyValuePair<object, object> myKvp2 = new KeyValuePair<object, object>(someKey2, someValue2);
KeyValuePair<object, object> myKvp3 = new KeyValuePair<object, object>(someKey3, someValue3);

Foo foo = new Foo(myKvp1, myKvp2, myKvp3);

Answer 3

Yes. The ability to use optional and named parameters was added in, I believe, C# 4.0.

http://msdn.microsoft.com/en-us/library/dd264739(v=vs.100).aspx

Answer 4

Using of tuples is another way to solve this problem.

Here is the example code:

//  if you want, replace dynamic type with all object types
static void CSharpKwargs(params (string name, object value)[] kwargs)
{
    foreach ((string name, object value) in kwargs)
    {
        Console.WriteLine($"{name}: {value}");
    }
}

If you want kwargs as a Dictionary do this:

Dictionary<string, object> kwargsAsDictionary = kwargs.ToDictionary(x => x.name, x => x.value);

Usage:

GetKwargs(("intParam", 1), ("stringParam", "2"));
//  Output will this:
//    intParam: 1
//    stringParam: 2

Answer 5

void paramsExample(object arg1, object arg2, params object[] argsRest)
{
    foreach (object arg in argsRest)
    { /* .... */ }
}

call it like this,

paramsExample(1, 0.0f, "a string", 0.0m, new UserDefinedType());

Answer 6

You can use a param list as your final argument to the function, like this:

void paramsExample(object arg1, object arg2, params object[] argsRest) {
    foreach (object arg in argsRest)
    { /* .... */ }
}

the method can be invoked with any number of arguments of any type.

paramsExample(1, 0.0f, "a string", 0.0m, new UserDefinedType());

This is a strongly typed argument so if I wanted to use a list of strings I could do this:

 public string Concat(string separator, params string[] strings) {
      string result = "";
      for (int i = 0; i < strings.Length; i++) {
          if (i > 0)
              result += separator;
          result += strings[i];
      }    
      return result;
 }

To invoke:

MessageBox.Show(Concat("+", "Anders", "Eric", "Scott", "Duncan") + " = great team");

Check out more info here: http://blogs.msdn.com/b/csharpfaq/archive/2004/05/13/how-do-i-write-a-method-that-accepts-a-variable-number-of-parameters.aspx