Appel d'une méthode statique à l'aide d'un type

Question

Comment appeler une méthode statique à partir d'un Type, en supposant que je connaisse la valeur de la variable Type et le nom de la méthode statique ?

public class FooClass {
    public static FooMethod() {
        //do something
    }
}

public class BarClass {
    public void BarMethod(Type t) {
        FooClass.FooMethod()          //works fine
        if (t is FooClass) {
            t.FooMethod();            //should call FooClass.FooMethod(); compile error
        }
    }
}

Ainsi, compte tenu d'un Type t, l'objectif est d'appeler FooMethod() sur la classe qui est de Type t. En gros, je dois inverser l'opérateur typeof().

Answer 1

Vous devez appeler la méthode MethodInfo.Invoke :

public class BarClass {
    public void BarMethod(Type t) {
        FooClass.FooMethod(); //works fine
        if (t == typeof(FooClass)) {
            t.GetMethod("FooMethod").Invoke(null, null); // (null, null) means calling static method with no parameters
        }
    }
}

Bien sûr, dans l'exemple ci-dessus, vous pouvez tout aussi bien appeler FooClass.FooMethod car il est inutile d'utiliser la réflexion pour cela. L'exemple suivant est plus logique :

public class BarClass {
    public void BarMethod(Type t, string method) {
        var methodInfo = t.GetMethod(method);
        if (methodInfo != null) {
            methodInfo.Invoke(null, null); // (null, null) means calling static method with no parameters
        }
    }
}

public class Foo1Class {
  static public Foo1Method(){}
}
public class Foo2Class {
  static public Foo2Method(){}
}

//Usage
new BarClass().BarMethod(typeof(Foo1Class), "Foo1Method");
new BarClass().BarMethod(typeof(Foo2Class), "Foo2Method");    

Answer 2

Vérifiez dans la classe MethodInfo et les méthodes GetMethod() sur Type.

Il existe un certain nombre de surcharges différentes pour différentes situations.

Answer 3

Notez que 10 ans se sont écoulés. Personnellement, j'ajouterais la méthode d'extension :

public static TR Method<TR>(Type t, string method, object obj = null, params object[] parameters) 
    => (TR)t.GetMethod(method)?.Invoke(obj, parameters);

et puis je pourrais l'appeler avec

var result = typeof(Foo1Class).Method<string>(nameof(Foo1Class.Foo1Method));