如何调用具有方法属性的方法？

Question

我在类中有多个方法实例，我需要快速调用和编写这些方法，而无需将它们添加到我的主函数中。这将如何用一个属性来完成？

例如 我有很多不同的类都有一个叫做“调用”的方法。我想添加一个自定义属性，我可以将其添加到此方法中，然后在称为“全部调用”的不同方法中对这些类中的每一个调用调用方法。

类似的东西看起来像这样，但很实用。

public class main_class
{ 
   public void invoke_all()
   {
      // call all the invokes
   }

}

public class test1
{
   [invoke]
   public void invoke()
   {
      Console.WriteLine("test1 invoked");
   }
}
public class test2
{
   [invoke]
   public void invoke()
   { 
     Console.WriteLine("test2 invoked");
   }
}

Answer 1

这对我来说有点不清楚，但我想我有一个解决方案：

您不能直接按照您的要求进行操作，但有一种解决方法 - 创建仅包含一种方法的接口：invoke（或更多，请随意），在 main 方法中，创建实现您的接口的对象列表 -或者只是创建为一个字段并在该方法中使用它。然后，在简单的foreach 循环中，您可以对列表中的每个项目调用Invoke 方法（这是可能的，因为它们实现了与该方法的接口）。

Answer 2

使用反射的过程很简单：找到所有感兴趣的类型t，从类型t中获取所有方法m，然后为每个m找到它的自定义属性a，然后如果集合a 包含你想要的属性，你调用方法。

另见：

• Find Types in All Assemblies
• Get class methods using reflection
• Find methods that have custom attribute using reflection

看起来像这样：

foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies())
{
    foreach (Type t in a.GetTypes())
    {
        // Skip types that don't have the [Invoke] attribute
        var typeContainsInvokeAttribute = t.GetCustomAttributes(typeof(InvokeAttribute)).Any();
        if (!typeContainsInvokeAttribute)
        {
            continue;
        }

        // This throws for types without a public, parameterless constructor
        var instance = Activator.CreateInstance(t);

        foreach (var methodInfo in instance.GetType().GetMethods())
        {
            var containsInvokeAttribute = methodInfo.GetCustomAttributes(typeof(InvokeAttribute)).Any();
            if (containsInvokeAttribute)
            {
                methodInfo.Invoke(instance);
            }

        }
    }
}

Answer 3

你可以使用静态事件代替属性

public static class Events
{
    public static event EventHandler OnInvoke;

    public static void Run()
    {
        OnInvoke?.Invoke(null, EventArgs.Empty);
    }
}

在类构造函数中订阅此事件

public class Customer
{
    public Customer()
    {
        Events.OnInvoke += (sender, args) => Call();
    }
}

但是不要忘记取消订阅此事件否则您的所有对象将永远不会被释放

这将在应用程序中的每个实例化（现有）对象上调用您的代码。意味着如果您有 2 个 test1 类型的对象，那么 Console.WriteLine("test1 invoked"); 将被执行两次

Answer 4

您可以根据您的要求创建基于接口的解决方案。

我已经修改了你的代码，并通过这种方式实现了你想要的。

namespace ConsoleApplication1
{
    public class main_class
    {
        static void Main(string[] args)
        {
            main_class.invoke_all();
        }

        public static void invoke_all()
        {
            // call all the invokes
            // Help : https://stackoverflow.com/questions/26733/getting-all-types-that-implement-an-interface

            foreach (Type mytype in System.Reflection.Assembly.GetExecutingAssembly().GetTypes()
                 .Where(mytype => mytype.GetInterfaces().Contains(typeof(IInvokeAll))))
            {
                mytype.GetMethod("invoke").Invoke(Activator.CreateInstance(mytype, null), null);
            }

            //wait for user input
            Console.ReadLine();
        }

    }

    interface IInvokeAll
    {
        void invoke();
    }

    public class test1 : IInvokeAll
    {
        //[invoke]
        public void invoke()
        {
            Console.WriteLine("test1 invoked");
        }
    }
    public class test2 : IInvokeAll
    {
        //[invoke]
        public void invoke()
        {
            Console.WriteLine("test2 invoked");
        }
    }
}

Answer 5

这是一个示例代码，用于实现您使用委托的目的。

public class main_class
{
    private static main_class instance;

    public delegate void MethodInvoker();

    public MethodInvoker MyInvoker { get; set; }

    public static main_class Instance
    {
        get
        {
            if (instance == null)
            {
                instance = new main_class();
            }

            return instance;
        }
    }

    private main_class() { }

    public void invoke_all()
    {
        MyInvoker();
    }

}

public class test1
{
    public test1()
    {
        main_class.Instance.MyInvoker += invoke;
    }
    public void invoke()
    {
        Console.WriteLine("test1 invoked");
    }
}
public class test2
{
    public test2()
    {
        main_class.Instance.MyInvoker += invoke;
    }
    public void invoke()
    {
        Console.WriteLine("test2 invoked");
    }
}

所以现在，无论您调用main_class.Instance.invoke_all();，它都会调用所有方法。

Answer 6

要调用方法，您需要实例化一个类。要实例化一个类，您需要知道类型。

所以我们需要

1. 查找所有包含带有Invoke 属性标记的方法的类
2. 然后实例化这些类
3. 调用所有标记的方法。

我们先定义属性：

public class InvokeAttribute : Attribute
{
}

你可以使用这个属性来标记方法：

public class TestClass1
{
    [Invoke]
    public void Method1()
    {
        Console.WriteLine("TestClass1->Method1");
    }
    [Invoke]
    public void Method2()
    {
        Console.WriteLine("TestClass1->Method2"););
    }
}

public class TestClass2
{
    [Invoke]
    public void Method1()
    {
        Console.WriteLine("TestClass2->Method1");
    }
}

现在如何查找和调用这些方法：

var methods = AppDomain.CurrentDomain.GetAssemblies() // Returns all currenlty loaded assemblies
        .SelectMany(x => x.GetTypes()) // returns all types defined in this assemblies
        .Where(x => x.IsClass) // only yields classes
        .SelectMany(x => x.GetMethods()) // returns all methods defined in those classes
        .Where(x => x.GetCustomAttributes(typeof(InvokeAttribute), false).FirstOrDefault() != null); // returns only methods that have the InvokeAttribute

foreach (var method in methods) // iterate through all found methods
{
    var obj = Activator.CreateInstance(method.DeclaringType); // Instantiate the class
    method.Invoke(obj, null); // invoke the method
}

上面的 sn-p 将检查所有加载的程序集。 linq 查询

1. 选择所有类型并过滤所有类
2. 然后它会读取这些类中定义的所有方法
3. 并检查这些方法是否标有InvokeAttribute

这为我们提供了MethodInfos 的列表。方法信息包含DeclaringType，即声明该方法的类。

我们可以使用Activator.CreateInstance 来实例化这个类的一个对象。这只有在类有一个没有参数的公共构造函数时才有效。

然后我们可以使用MethodInfo 来调用之前创建的类实例上的方法。这只有在方法没有参数时才有效。