CODEWITHSUNDEEP
c#reflectioninvoke
Gojira
Gojira

Reputation: 3041

Why does Method Invoke fail with argument exception?

Consider this code sample from a WinForms app:

public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            object[] parms = new object[1];
            parms[0] = "foo";

            DoSomething(parms);
        }

        public static string DoSomething(object[] parms)
        {
            Console.WriteLine("Something good happened");
            return null;
        }
    }

It works as expected, when you click button1 it prints "Something good happened" to the console.

Now consider this code sample, which is the same except that it invokes DoSomething using reflection:

public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            object[] parms = new object[1];
            parms[0] = "foo";

            System.Reflection.MethodInfo mi = typeof(Form1).GetMethod("DoSomething");
            mi.Invoke(null, parms);

        }

        public static string DoSomething(object[] parms)
        {
            Console.WriteLine("Something good happened");
            return null;
        }
    }

It throws an System.ArgumentException on the line mi.Invoke(null, parms) (Object of type 'System.String' cannot be converted to type 'System.Object[]'.)

parms is clearly an object array, and DoSomething's method signature is clearly expecting an object array. So why is invoke pulling the first object out of the array and trying to pass that instead?

Or is something else going on that I'm not understanding?

Upvotes: 3

Views: 1847

Answers (4)

CodingYoshi
CodingYoshi

Reputation: 26989

parms is clearly an object array, and DoSomething's method signature is clearly expecting an object array.

Yes it is expecting an object array. But when you pass this:

object[] parms = new object[1];

You are saying these are the arguments for DoSomething so parms[0] is the first argument to DoSomething and if there were more items in parms then parms[1] will be the 2nd argument and so on.

Clearly the first argument for DoSomething is not a string (parms[0]) so you get this error:

It throws an System.ArgumentException on the line mi.Invoke(null, parms) (Object of type 'System.String' cannot be converted to type 'System.Object[]'.)

Upvotes: 1

Gusman
Gusman

Reputation: 15151

MethodInfo.Invoke expects an array of objects as parameter to pass multiple arguments to the functions, each object in the array will be a different parameter.

As your function also expects an object array you are passing as argument not an object array but an string.

You must wrap that array into another array, in this way the Invoke will unwrap the first array and use the inner array as the first parameter for the call.

mi.Invoke(null, new object[]{ parms });

Upvotes: 1

Servy
Servy

Reputation: 203802

MethodInfo.Invoke is expecting an object array, where each object in the object array corresponds to an argument to the method. The first argument in the object array is the first argument, the second object in the array the second method, etc.

Since you want the first argument to your method to be an object[], you need to ensure that the first object in the object array you pass to MethodInfo.Invoke is an object array that represents the array that DoSomething should use.

Upvotes: 6

Marc Gravell
Marc Gravell

Reputation: 1062512

object[] parms = new object[1];
parms[0] = "foo";

with:

public static string DoSomething(object[] parms)

that's the problem; the first parameter is not a string - it is an object[]. The object[] that you pass to Invoke represents each parameter in turn, so an object[] of length 1 with a string would match static string DoSomething(string s), but does not match your method. Either change the signature, or wrap the value. Frankly, I suggest changing the signature is the better idea here, but:

parms[0] = new object[] { "foo" };

would also work

Upvotes: 2

Related Questions