Does C# Support a Variable Number of Arguments, and How

Does C# support a variable number of arguments, and how?

Yes. The classic example wourld be the params object[] args:

//Allows to pass in any number and types of parameters
public static void Program(params object[] args)

A typical usecase would be passing parameters in a command line environment to a program, where you pass them in as strings. The program has then to validate and assign them correctly.

Restrictions:

• Only one params keyword is permitted per method
• It has to be the last parameter.

EDIT: After I read your edits, I made mine. The part below also covers methods to achieve variable numbers of arguments, but I think you really were looking for the params way.

---

Also one of the more classic ones, is called method overloading. You've probably used them already a lot:

//both methods have the same name and depending on wether you pass in a parameter
//or not, the first or the second is used.
public static void SayHello() {
    Console.WriteLine("Hello");
}
public static void SayHello(string message) {
    Console.WriteLine(message);
}

---

Last but not least the most exiting one: Optional Arguments

//this time we specify a default value for the parameter message
//you now can call both, the method with parameter and the method without.
public static void SayHello(string message = "Hello") {
    Console.WriteLine(message);
}

http://msdn.microsoft.com/en-us/library/dd264739.aspx

Function with variable number of arguments

Yes you can write something like this:

void PrintReport(string header, params int[] numbers)
{
    Console.WriteLine(header);
    foreach (int number in numbers)
        Console.WriteLine(number);
}

Can I make a method in C# accept a variable number of arguments and then process these

You can use params like so from the documentation

public static void UseParams(params int[] list)
{
    for (int i = 0; i < list.Length; i++)
    {
        Console.Write(list[i] + " ");
    }
    Console.WriteLine();
}

C# function with variable number of arguments causes confusion when multiple overloads available

The problem you are seeing is caused because the first item in your method call is a string and therefore will alway match the second method call. You can do 1 of the following to get around the problem:

If the order of the args is not important you could simply make sure that the first item is not a string:

this.GetErrorMessage(5, "Ticket Count");

Or you can cast the string to an object:

this.GetErrorMessage((object)"Ticket Count", 5);

You could always make this call however it does break the whole purpose of using params:

this.GetErrorMessage(new object[] {"Ticket Count", 5 });

How do I write a C# method that takes a variable number of arguments?

You would do this as:

string ConcatString(params string[] arguments)
{
   // Do work here
}

This can be called as:

string result = ConcatString("Foo", "Bar", "Baz");

For details, see params (C# Reference).

---

FYI - There is already a String.Concat(params object[] args) - it will concatenate any set of objects by calling ToString() on each. So for this specific example, this is probably not really that useful.

.Net - passing variable number of arguments

Using this tutorial I came up with the following code:

System::Reflection::Emit::DynamicMethod ^CreateHandler()
{
    // Get event handler type
    auto delegateType = _event->EventHandlerType;
    assert(delegateType);

    auto invoke = delegateType->GetMethod("Invoke");
    assert(invoke);

    // Get return type
    auto returnType = invoke->ReturnType;

    // Get parameters list
    auto delegateParameters = GetParameterTypes(invoke);

    // First parameter should be a pointer to my handler class
    auto parameters = gcnew array<System::Type ^> (delegateParameters->Length + 1);
    parameters[0] = MyHandlerClass::typeid;
    delegateParameters->CopyTo(parameters, 1);

    // Create dynanic method for my handler class
    auto handler = gcnew System::Reflection::Emit::DynamicMethod(
        _event->Name + "Handler",
        returnType,
        parameters,
        MyHandlerClass::typeid
    );

    // This method should be called
    auto method = MyHandlerClass::typeid->GetMethod("GeneralEventHandler");

    // Add method body
    auto codeGen = handler->GetILGenerator();

    // Get type of 'object[]'
    auto arrayType = System::Object::typeid->MakeArrayType();

    // Create local variable 'args' (at index 0) of type 'object[]'
    auto localArgs = codeGen->DeclareLocal(arrayType);

    // Create an array of arguments of required size
    codeGen->Emit(System::Reflection::Emit::OpCodes::Ldc_I4, delegateParameters->Length);   // Array size
    codeGen->Emit(System::Reflection::Emit::OpCodes::Newarr, System::Object::typeid);       // Creating array
    codeGen->Emit(System::Reflection::Emit::OpCodes::Stloc_0);                              // Store to local variable at index 0 ('args')

    // Fill array
    for (int i = 0; i < delegateParameters->Length; i++)
    {
        // Store (i + 1) argument to array at index i
        codeGen->Emit(System::Reflection::Emit::OpCodes::Ldloc_0);          // Refer to array
        codeGen->Emit(System::Reflection::Emit::OpCodes::Ldc_I4, i);        // Move to index i
        codeGen->Emit(System::Reflection::Emit::OpCodes::Ldarg_S, i + 1);   // Refer to (i + 1) argument

        // Is argument of simple type?
        if (delegateParameters[i]->IsValueType)
        {
            // Pack argument
            codeGen->Emit(System::Reflection::Emit::OpCodes::Box, delegateParameters[i]);
        }

        // Store element to array
        codeGen->Emit(System::Reflection::Emit::OpCodes::Stelem_Ref);
    }

    // Now we put everything on stack:
    // 'this' pointer
    codeGen->Emit(System::Reflection::Emit::OpCodes::Ldarg_0);

    // Nane of event (for identification)
    codeGen->Emit(System::Reflection::Emit::OpCodes::Ldstr, _event->Name);

    // Array of arguments
    codeGen->Emit(System::Reflection::Emit::OpCodes::Ldloc_0);

    // Now call the method
    codeGen->Emit(System::Reflection::Emit::OpCodes::Call, method);

    // And return
    codeGen->Emit(System::Reflection::Emit::OpCodes::Ret);

    return handler;
}

The handler class looks like this:

ref class MyHandlerClass
{
public:

    void GeneralEventHandler(System::String ^name, array<System::Object ^> ^params);
}

And then I just use this dynamic method to connect to the event:

System::Delegate ^Connect(System::Object ^instance, MyHandlerClass ^handler)
{
    auto method = CreateHandler();
    assert(method);

    // Создадим делегат
    auto delegate = method->CreateDelegate(_event->EventHandlerType, handler);
    assert(delegate);

    // Добавим в список обработчиков
    _event->AddEventHandler(instance, delegate);

    return delegate;
}

The code is written in C++/CLI but it's fairly easy to convert in to C#.

The idea is the same as in my initial post, I just added the array of objects generation code.

Passing Variable Number of Arguments

I would recommend building a struct and then passing those in as params. In my example, your struct represents a score of some kind:

public struct RaceScore
{
     public bool FinishedRace;
     public int Points;
}

Your method signature would then be:

public void SaveScores(params RaceScore[] scores)

Here's an example of calling SaveScores:

RaceScore score = new RaceScore() { FinishedRace = true, Points = 20 };
RaceScore score2 = new RaceScore() { FinishedRace = false, Points = 15 };
SaveScores(score, score2);

Passing variable number of parameters in class constructor C#

I believe you're missing the [] on the List declaration in your method signature in order to declare it as a parameter array.

Try public EvoObject(Object _id, params List<Int32>[] _args)

---

Related Topics