I'm referring specifically to how the reflection API methods (ie GetMethod,
GetProperty, etc) treat inherited members in interfaces as opposed to
inherited members in classes.

Run the following code. GetMethod finds the inherited method in the derived
class, but not in the derived interface. I realise that you can dig up the
hierachy with reflection to find the inherited members, but the code
performing the reflection is in a third party library we are using.

I suspect this is somehow the by design behaviour rather than a bug. But I'm
trying to understand the reason why the behaviour should differ between
interfaces and classes in this way.

Niall

using System;
using System.Reflection;

namespace ReflectionTest
{
    class Program
    {
        static void Main(string[] args)
        {
            MethodInfo iMi = typeof(IChild).GetMethod("DoParent", BindingFlags.Public

            MethodInfo mi = typeof(Child).GetMethod("DoParent", BindingFlags.Public |
BindingFlags.Instance);

            Console.WriteLine("Interface method: " + ((iMi == null) ? "null" : "not
null"));
            Console.WriteLine("Class method:     " + ((mi == null) ? "null" : "not
null"));

            Console.ReadLine();
        }
    }

    public interface IParent
    {
        void DoParent();
    }

    public interface IChild : IParent
    {
        void DoChild();
    }

    public class Parent : IParent
    {
        public void DoParent()
        {
        }
    }

    public class Child : Parent, IChild
    {
        public void DoChild()
        {
        }
    }
}