在 C# 中调用具有方法属性的非静态方法

Question

I currently have a working system that when a static method has an event attribute and a single param of type Event then it can be called by the EventSystem.

Example method

[EventAtribute]
public static void thisIsAnEventHandler(Event ev)
{
  print(ev.ToStrring());
}

When I call this function it gets all methods with this event type and calls it, MethodInfo.Invoke takes a obj of null as all the method are static.

public static void callMethodsWithEvent(Event ev)
        {
            // triggers when initEventSystem has not been called
            Debug.Assert(_eventMethods != null);
            
            var methods = _eventMethods
            .Where(x => x.GetParameters()[0].ParameterType == ev.GetType())
            .Where(x => x.GetParameters().Length == 1)
            .Where(x => x.IsStatic);

            foreach (var method in methods) // iterate through all found methods
            {
                method.Invoke(null, new object[] {ev});
            }
        }

How all methods are stored on startup

public static void initEventSystem()
        {
            _eventMethods = 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())
                .Where(x => x.GetCustomAttributes(typeof(EventAtribute), false).FirstOrDefault() != null)
                .ToList();
        }

Even though this system work great it only works static methods. I know I need to pass a object reference into the Invoke method but I want to be able to create events and and let any method with that event be called without me having to think about it.

So I think what I need is to be able to get all object with this method signature and call all of those methods in all of those objects individually. Is there any way to do this without walking through the heap.

Thanks.

Answer 1

With the comments above, I suggest a solution such as the following (just a broad idea, the implementation will need more details). And yes, an interface only offers methods, no implementation. But that's exactly the same as with a delegate, it is also only a definition on how to call a certain method, but not the implementation itself. An interface can actually be seen as a collection of delegates joined together.

Create an attribute that can be attached to classes, telling your event system that these classes can receive certain events:

    /// <summary>
    /// Declares the visibility of a component.
    /// </summary>
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
    public sealed class InterfaceSupportAttribute : Attribute
    {
        private Type[] m_supportedInterfaces;

        public InterfaceSupportAttribute()
        {
            m_supportedInterfaces= new Type[0];
        }

        public Type[] SupportedInterfaces
        {
            get => m_external;
            set => m_external = value.Distinct().ToArray();
        }
    }

Used as follows:

public interface IMyFunctionality
{
    public void Foo();
}

[InterfaceSupportAttribute(SupportedInterfaces = new[] {typeof(IMyFunctionality)}) 
public class MyClass : IMyFunctionality
{
   public MyClass() {...}
   public void Foo() {...}
}

Then, somewhere else in the code:

MyClass c = new MyClass();
RegisterType(c);

And the RegisterType function extracts the attribute and retains a reference to the class. Another function is then used to query all classes that implement IMyInterface . You can implement these functions yourself or use an existing Dependency Injection Framework , such as NInject. These offer exactly the functions to register classes (and their interfaces) and query the registered classes for a certain interface.

Note: I have never worked with unity, but I would actually assume that it already includes such a dependency injection framework, as a lot of larger software packages use it in one form or the other.