How can I use reflection in C# to find all the members of a class that meet the requirements of a specific delegate?

Question

Hi,

I've got a class that's got a bunch of public methods, and I'd like to reflect over it to find the set of member methods that could be used as a particular delegate.

For example:

delegate void InterestingFunc(int i);

class Entity
{
    public void F();
    public void G();
    public void H(int i);
    public void X(int i);
}

Can I use Type.FindMembers() to pull out the set { H, X }? If so, how? Is there a better way?

Answer 1

There is no inherent query support in Type which will find methods based on a delegate signature. You would need to hand code a search method which loops through methods and properties manually comparing the signatures to that of the proposed delegate.

This itself is a non-trivial operation as you need to take generics into account with your solution.

Answer 2

This itself is a non-trivial operation as you need to take generics into account with your solution.

100% correct -- not to mention ref/out parameters, param[] modifiers, as well as unsafe pointers.

One non-optimal option is to apply Delegate.CreateDelegate to each method in Entity, taking note of when the construction fails. The failures denote the incompatible methods.

Again, you will likely have to do some work to handle the case of generic methods.

Answer 3

Here's a start:

   MethodInfo[] FindMethods(Type delegateType, Type sourceType)
    { 
      var dInfo       = delegateType.GetMethod("Invoke");
      var dParamTypes = delegateInfo.GetParameters().Select(p=>p.ParameterType);

      var methods = from methodInfo in sourceType.GetMethods()
                    let mParamTypes = methodInfo.GetParameters()
                                                .Select(p=>p.ParameterType)
                    where    methodInfo.ReturnType == delegateInfo.ReturnType
                          && mParamTypes.SequenceEqual(dParamTypes)
                    select methodInfo;

      return methods.ToArray();
    }

It can be expanded to take into account generics, ref/out parameters, and anything else. Test-driven development would be particularly helpful here.