6 out of 13 rated this helpful - Rate this topic

params (C# Reference)

The params keyword lets you specify a method parameter that takes a variable number of arguments.

You can send a comma-separated list of arguments of the type specified in the parameter declaration, or an array of arguments of the specified type. You also can send no arguments.

No additional parameters are permitted after the params keyword in a method declaration, and only one params keyword is permitted in a method declaration.

The following example demonstrates various ways in which arguments can be sent to a params parameter.


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

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

    static void Main()
    {
        // You can send a comma-separated list of arguments of the 
        // specified type.
        UseParams(1, 2, 3, 4);
        UseParams2(1, 'a', "test");

        // A params parameter accepts zero or more arguments.
        // The following calling statement displays only a blank line.
        UseParams2();

        // An array argument can be passed, as long as the array
        // type matches the parameter type of the method being called.
        int[] myIntArray = { 5, 6, 7, 8, 9 };
        UseParams(myIntArray);

        object[] myObjArray = { 2, 'b', "test", "again" };
        UseParams2(myObjArray);

        // The following call causes a compiler error because the object
        // array cannot be converted into an integer array.
        //UseParams(myObjArray);

        // The following call does not cause an error, but the entire 
        // integer array becomes the first element of the params array.
        UseParams2(myIntArray);
    }
}
/*
Output:
    1 2 3 4
    1 a test

    5 6 7 8 9
    2 b test again
    System.Int32[]
*/


For more information, see the C# Language Specification. The language specification is the definitive source for C# syntax and usage.

Did you find this helpful?
(1500 characters remaining)
Community Content Add
Annotations FAQ
My daily usage
This is how I use it "daily":

public static void AppendAllText(String path, String contents, params Encoding[] encoding)
        {
            AppendAllText(null, path, contents, encoding != null && encoding.Any() ? encoding[0] : DefaultEncoding);
        }
Using null as params argument value

Executive summary:
UseParams2(null) yields list=null, not list=new object[] { null }.
This means that using "params" does not guarantee you will actually receive an array; remember to check for null values to avoid a NullReferenceException.

With the methods specifications
    public static void UseParams(params int[] list) { Console.WriteLine(list==null); }
    public static void UseParams2(params object[] list) { Console.WriteLine(list==null); }
then
    UseParams(null) will obviously print True, but
    UseParams2(null) could correspond to both UseParams2(null) and UseParams2(new object[] {null}), seeing as how null is implicitly convertible to both object[] (the array type) and object (the array element type).

The specification covers the params keyword in sections 1.6.6.1 and 10.6.1.4, and the latter is recommended reading :) It says that the "normal form" is preferred over the "expanded form". The "expanded form" means using the params keyword to automagically create an array. So situations where you avoid creating an array will be preferred. This also applies to overloaded functions (which you might want to avoid array creation where [memory] performance is critical).