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, étant donné un Type t, l'objectif est d'appeler FooMethod() sur la classe qui est de Type t. Fondamentalement, j'ai besoin d'inverser l'opérateur typeof().

Answer 1

Vous devez appeler MethodInfo.Invoke méthode:

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

Bien sûr, dans l'exemple ci-dessus, vous pourriez aussi bien appeler FooClass.FooMethod car il n'y a pas de point en utilisant 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 - means calling static method 
     } 
    } 
} 

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.