C＃类型GetMethod（），其中参数顺序是随机的

Question

I am trying to get a method of an object, and it works fine if the parameters of the method match the order of the list of parameters I provide. I am trying to avoid this, so I do not have to worry about the order of parameter types in methods across different files. Here is what I have

MethodInfo mi = stateType.GetMethod("Entrance", typesToUse.ToArray());

In my test case, typesToUse only contains two instances of unique interfaces, IClass1 and IClass2 in that order.

If the Entrance method is : Entrance(IClass1 c1, IClass2 c2), it picks this method up. Although, if its Entrance(IClass2 c2, IClass1 c1), it will not and mi will then be null.

Is there a way around this? Perhaps a way to tell GetMethod to ignore parameter order?

Any help is appreciated and thank you.

Answer 1

It is not sensible to implement a method that will ignore parameter order. Parameter order is critical to determining that you have found the correct method.

Consider this simple class:

public class A 
{
    public void Foo(int a, string b)
    {
        PrintAString();
    }

    public void Foo(string b, int a)
    {
        FormatHardDrive();
    }

}

If you're method ignored the parameter order...bad things might happen!

Having said all that, it is possible of course. Simply get all the methods with a given name, eliminate all those that do not contain parameters for all the types in typesToUse , and then ensure you only have one.

The following code demonstrates this:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;

public class Program
{
    public static void Main()
    {
        var typesToUse = new Type[] { typeof(int), typeof(string) };
        var methods = typeof(A).GetMethods().Where(m => m.Name == "Foo");

        var matchingMethods = methods.Where(m => ContainsAllParameters(m, typesToUse));

        Console.WriteLine(matchingMethods.Single());
    }

    private static bool ContainsAllParameters(MethodInfo method, Type[] typesToUse) 
    {
        var methodTypes = method.GetParameters().Select(p => p.ParameterType).ToList();

        foreach(var typeToUse in typesToUse)
        {
            if (methodTypes.Contains(typeToUse))
            {
                methodTypes.Remove(typeToUse);
            }
            else 
            {
                return false;       
            }
        }

        return !methodTypes.Any();
    }

}

public class A
{
    public void Foo(string a, int b) 
    {
        Console.WriteLine("Hello World");
    }
}

Answer 2

You could create an overload of the method, that takes the parameters in different order.

The recommended solution would probably just be to make sure they always are passed in the correct order.

If you can't ensure this, you might solve the problem by creating an overload of the method, or by performing some checks as the first thing in the Entrance-method.