System.Reflection.TargetParameterCountException – Parameter count mismatch

The System.Reflection.TargetParameterCountException with the message “Parameter count mismatch” occurs in C# when you attempt to invoke a method or constructor using reflection, but the number of arguments provided does not match the number of parameters expected by the method or constructor.

Common Causes and Solutions

1. Incorrect Number of Arguments:
   If you pass too many or too few arguments when invoking a method or constructor via reflection, this exception will be thrown.

   public class Example
   {
       public void PrintMessage(string message) => Console.WriteLine(message);
   }

   var method = typeof(Example).GetMethod("PrintMessage");
   method.Invoke(new Example(), new object[] { }); // TargetParameterCountException – Missing argument

Fix: Ensure the number of arguments matches the method’s parameter count.

   method.Invoke(new Example(), new object[] { "Hello" }); // Correct number of arguments

2. Mismatch in Overloaded Methods:
   If there are multiple overloaded methods and you do not specify the correct one, this exception can occur.

   public class Example
   {
       public void PrintMessage(string message) => Console.WriteLine(message);
       public void PrintMessage(string message, int count) => Console.WriteLine($"{message} {count}");
   }

   var method = typeof(Example).GetMethod("PrintMessage");
   method.Invoke(new Example(), new object[] { "Hello" }); // TargetParameterCountException – Ambiguous method

Fix: Specify the exact method by providing parameter types.

   var method = typeof(Example).GetMethod("PrintMessage", new[] { typeof(string) });
   method.Invoke(new Example(), new object[] { "Hello" }); // Correct method

3. Invoking Constructors:
   If you pass the wrong number of arguments when invoking a constructor via reflection, this exception will occur.

   public class Example
   {
       public Example(string message) => Console.WriteLine(message);
   }

   var constructor = typeof(Example).GetConstructor(new[] { typeof(string) });
   constructor.Invoke(new object[] { }); // TargetParameterCountException – Missing argument

Fix: Provide the correct number of arguments for the constructor.

   constructor.Invoke(new object[] { "Hello" }); // Correct number of arguments

4. Using MethodInfo with Optional Parameters:
   If the method has optional parameters and you do not provide values for them, this exception can occur.

   public class Example
   {
       public void PrintMessage(string message, int count = 1) => Console.WriteLine($"{message} {count}");
   }

   var method = typeof(Example).GetMethod("PrintMessage");
   method.Invoke(new Example(), new object[] { "Hello" }); // TargetParameterCountException – Missing optional argument

Fix: Provide values for all parameters, including optional ones.

   method.Invoke(new Example(), new object[] { "Hello", 1 }); // Provide all arguments

5. Invoking Methods with params:
   If the method has a params parameter and you do not pass an array, this exception can occur.

   public class Example
   {
       public void PrintMessages(params string[] messages) => Console.WriteLine(string.Join(", ", messages));
   }

   var method = typeof(Example).GetMethod("PrintMessages");
   method.Invoke(new Example(), new object[] { "Hello" }); // TargetParameterCountException – Incorrect argument type

Fix: Pass the arguments as an array.

   method.Invoke(new Example(), new object[] { new[] { "Hello", "World" } }); // Correct argument type

6. Using DynamicMethod or Delegate:
   If you create a DynamicMethod or Delegate with an incorrect number of parameters, this exception can occur.

   var method = new DynamicMethod("PrintMessage", typeof(void), new[] { typeof(string) });
   var delegateInstance = method.CreateDelegate(typeof(Action<int>)); // TargetParameterCountException – Parameter count mismatch

Fix: Ensure the delegate signature matches the method’s parameters.

   var delegateInstance = method.CreateDelegate(typeof(Action<string>)); // Correct delegate type