调用带有反射的静态方法

Question

我在命名空间mySolution中有几个静态类

static class Indent{    
     public static void Run(){
         // implementation
     }
     // other helper methods
}

所以我的问题是，如何在反射的帮助下调用这些方法？

如果方法不是静态的，那么我可以这样做：

var macroClasses = Assembly.GetExecutingAssembly().GetTypes().Where( x => x.Namespace.ToUpper().Contains("MACRO") );

foreach (var tempClass in macroClasses)
{
   var curInsance = Activator.CreateInstance(tempClass);
   // I know have an instance of a macro and will be able to run it

   // using reflection I will be able to run the method as:
   curInsance.GetType().GetMethod("Run").Invoke(curInsance, null);
}

我想让我的课程保持不变。我怎样才能用静态方法做类似的事情？

简而言之，我想从命名空间mySolution. Macros中的所有静态类调用所有Run方法。




Answer 1

将调用方法的类：

namespace myNamespace
{
    public class myClass
    {
        public static void voidMethodWithoutParameters()
        {
            // code here
        }
        public static string stringReturnMethodWithParameters(string param1, string param2)
        {
            // code here
            return "output";
        }
    }
}

使用反射调用myClass静态方法：

var myClassType = Assembly.GetExecutingAssembly().GetType(GetType().Namespace + ".myClass");
                    
// calling my void Method that has no parameters.
myClassType.GetMethod("voidMethodWithoutParameters", BindingFlags.Public | BindingFlags.Static).Invoke(null, null);

// calling my string returning Method & passing to it two string parameters.
Object methodOutput = myClassType.GetMethod("stringReturnMethodWithParameters", BindingFlags.Public | BindingFlags.Static).Invoke(null, new object[] { "value1", "value1" });
Console.WriteLine(methodOutput.ToString());

注意：我不需要实例化myClass的对象来使用它的方法，因为我使用的方法是静态的。

巨大的资源：

• C#Reflection如何工作

Answer 2

通过只创建一次委托（也不需要实例化类来调用静态方法），可以非常、非常、非常优化代码。我做了一些非常类似的事情，我只是在助手类的帮助下缓存一个“Run”方法的委托：-）。看起来是这样的：

static class Indent{    
     public static void Run(){
         // implementation
     }
     // other helper methods
}

static class MacroRunner {

    static MacroRunner() {
        BuildMacroRunnerList();
    }

    static void BuildMacroRunnerList() {
        macroRunners = System.Reflection.Assembly.GetExecutingAssembly()
            .GetTypes()
            .Where(x => x.Namespace.ToUpper().Contains("MACRO"))
            .Select(t => (Action)Delegate.CreateDelegate(
                typeof(Action), 
                null, 
                t.GetMethod("Run", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public)))
            .ToList();
    }

    static List<Action> macroRunners;

    public static void Run() {
        foreach(var run in macroRunners)
            run();
    }
}

这样速度快得多。

如果方法签名不同于Action，则可以将类型强制转换和类型化替换为所需的任何Action和Func泛型类型，或者声明委托并使用它。我自己的实现使用Func打印对象：

static class PrettyPrinter {

    static PrettyPrinter() {
        BuildPrettyPrinterList();
    }

    static void BuildPrettyPrinterList() {
        printers = System.Reflection.Assembly.GetExecutingAssembly()
            .GetTypes()
            .Where(x => x.Name.EndsWith("PrettyPrinter"))
            .Select(t => (Func<object, string>)Delegate.CreateDelegate(
                typeof(Func<object, string>), 
                null, 
                t.GetMethod("Print", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public)))
            .ToList();
    }

    static List<Func<object, string>> printers;

    public static void Print(object obj) {
        foreach(var printer in printers)
            print(obj);
    }
}

Answer 3

作为MethodInfo的文档。调用状态时，静态方法的第一个参数被忽略，因此可以只传递null。

foreach (var tempClass in macroClasses)
{
   // using reflection I will be able to run the method as:
   tempClass.GetMethod("Run").Invoke(null, null);
}

正如注释所指出的，您可能希望在调用Getmethod时确保该方法是静态的：

tempClass.GetMethod("Run", BindingFlags.Public | BindingFlags.Static).Invoke(null, null);