47

How do I call a static method from a Type, assuming I know the value of the Type variable and the name of the static method?

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
        }
    }
}

So, given a Type t, the objective is to call FooMethod() on the class that is of Type t. Basically I need to reverse the typeof() operator.

Irshad
  • 3,071
  • 5
  • 30
  • 51
MrEff
  • 473
  • 1
  • 4
  • 4

3 Answers3

74

You need to call MethodInfo.Invoke method:

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
        }
    }
}

Of course in the above example you might as well call FooClass.FooMethod as there is no point using reflection for that. The following sample makes more sense:

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");
asyncful
  • 3
  • 3
Igor Zevaka
  • 74,528
  • 26
  • 112
  • 128
  • Thanks Igor, this will work fine (although I am disappointed in C#--it looks completely un-typesafe) In my actual code there are many classes that could be in the Type variable, so reflection is necessary. – MrEff Aug 02 '10 at 16:24
5

Note, that as 10 years have passed. Personally, I would add extension method:

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

and then I could call it with:

var result = typeof(Foo1Class).Method<string>(nameof(Foo1Class.Foo1Method));
FinalFortune
  • 635
  • 10
  • 25
Margus
  • 19,694
  • 14
  • 55
  • 103
2

Check into the MethodInfo class and the GetMethod() methods on Type.

There are a number of different overloads for different situations.

Rob Cooke
  • 968
  • 1
  • 6
  • 12