What is the maximum number of parameters that a C# method can be defined as taking?

Question

I am trying to figure out what the maximum number of parameters a method in C# can have. I've checked everywhere for an answer, including the C# official documentation, MSDN, and a couple of CLR references and I can't find an answer. Does anyone have an answer to this question?

Answer 1

I used a throwaway program to create a program to determine the maximum number of parameters I can pass to a method. Based on the results of my experimentation, the closest to an answer I can find are the following (all of which is only valid on my computer):

1. A .net application containing a method with 16383 parameters can be compiled, ran, and called (!)
2. A .net application containing 16384 or more parameters can be compiled, but running such a program throws an unstated exception.
3. A .net application containing 50000 parameters can also be compiled, but attempting to run such an application results in a StackOverflowException being thrown.
4. Attempting to compile a .net application containing 100000 parameters or more results in csc.exe giving a compile-time error, stating that the resulting expression is too long or complex to handle.

Aside from that, does anyone have a definitive answer to this question?

P.S. If anyone wants to try this experiment on their computer, you can start with my test program, which can be downloaded https://docs.google.com/open?id=0B1Q3uRTkbsXic2cwUFpXanNkSk0

Answer 2

Here is your theoretical answer:

In order to push method arguments onto the stack, compiled code has the following MSIL opcodes to choose from:

ldarg.0

ldarg.1

ldarg.2

ldarg.3

ldarg.S

ldarg

ldarg.0 to ldarg.3 is used to push the first 4 method arguments onto the stack (including this as the first argument for instance methods).

ldarg.S takes an 8-bit argument number, and so it can be used to push up to 256 arguments onto the stack.

That leaves us with plain old ldarg, which can handle the most method arguments: it takes an unsigned 16-bit argument number, so the largest number of arguments that can be successfully compiled into valid MSIL is 2^16 = 65,536.

As others have noted, however, the actual limit will depend on implementation details of the runtime. Based on rmiesen's answer, it looks like the current .NET implementation limits the maximum number of parameters to 2^14.