GetProperties () para devolver todas las propiedades de una jerarquía de herencia de interfaz

Suponiendo la siguiente jerarquía de herencia hipotética:

public interface IA
{
  int ID { get; set; }
}

public interface IB : IA
{
  string Name { get; set; }
}

Usando la reflexión y haciendo la siguiente llamada:

typeof(IB).GetProperties(BindingFlags.Public | BindingFlags.Instance) 

solo producirá las propiedades de la interfaz IB, que es " Name".

Si hiciéramos una prueba similar en el siguiente código,

public abstract class A
{
  public int ID { get; set; }
}

public class B : A
{
  public string Name { get; set; }
}

la llamada typeof(B).GetProperties(BindingFlags.Public | BindingFlags.Instance)devolverá una matriz de PropertyInfoobjetos para " ID" y " Name".

¿Existe una manera fácil de encontrar todas las propiedades en la jerarquía de herencia para interfaces como en el primer ejemplo?

He modificado el código de ejemplo de @Marc Gravel en un método de extensión útil que encapsula tanto las clases como las interfaces. También agrega las propiedades de la interfaz primero, que creo que es el comportamiento esperado.

public static PropertyInfo[] GetPublicProperties(this Type type)
{
    if (type.IsInterface)
    {
        var propertyInfos = new List<PropertyInfo>();

        var considered = new List<Type>();
        var queue = new Queue<Type>();
        considered.Add(type);
        queue.Enqueue(type);
        while (queue.Count > 0)
        {
            var subType = queue.Dequeue();
            foreach (var subInterface in subType.GetInterfaces())
            {
                if (considered.Contains(subInterface)) continue;

                considered.Add(subInterface);
                queue.Enqueue(subInterface);
            }

            var typeProperties = subType.GetProperties(
                BindingFlags.FlattenHierarchy 
                | BindingFlags.Public 
                | BindingFlags.Instance);

            var newPropertyInfos = typeProperties
                .Where(x => !propertyInfos.Contains(x));

            propertyInfos.InsertRange(0, newPropertyInfos);
        }

        return propertyInfos.ToArray();
    }

    return type.GetProperties(BindingFlags.FlattenHierarchy
        | BindingFlags.Public | BindingFlags.Instance);
}

Type.GetInterfaces devuelve la jerarquía aplanada, por lo que no hay necesidad de un descenso recursivo.

El método completo se puede escribir de manera mucho más concisa usando LINQ:

public static IEnumerable<PropertyInfo> GetPublicProperties(this Type type)
{
    if (!type.IsInterface)
        return type.GetProperties();

    return (new Type[] { type })
           .Concat(type.GetInterfaces())
           .SelectMany(i => i.GetProperties());
}

Las jerarquías de interfaz son una molestia, en realidad no "heredan" como tales, ya que puede tener varios "padres" (a falta de un término mejor).

"Aplanar" (de nuevo, no es el término correcto) la jerarquía puede implicar la comprobación de todas las interfaces que implementa la interfaz y trabajar desde allí ...

interface ILow { void Low();}
interface IFoo : ILow { void Foo();}
interface IBar { void Bar();}
interface ITest : IFoo, IBar { void Test();}

static class Program
{
    static void Main()
    {
        List<Type> considered = new List<Type>();
        Queue<Type> queue = new Queue<Type>();
        considered.Add(typeof(ITest));
        queue.Enqueue(typeof(ITest));
        while (queue.Count > 0)
        {
            Type type = queue.Dequeue();
            Console.WriteLine("Considering " + type.Name);
            foreach (Type tmp in type.GetInterfaces())
            {
                if (!considered.Contains(tmp))
                {
                    considered.Add(tmp);
                    queue.Enqueue(tmp);
                }
            }
            foreach (var member in type.GetMembers())
            {
                Console.WriteLine(member.Name);
            }
        }
    }
}

Exactamente el mismo problema tiene una solución que se describe aquí .

FlattenHierarchy no funciona por cierto. (solo en variables estáticas. lo dice en intellisense)

Solución alterna. Tenga cuidado con los duplicados.

PropertyInfo[] pis = typeof(IB).GetProperties(BindingFlags.Public | BindingFlags.Instance);
Type[] tt = typeof(IB).GetInterfaces();
PropertyInfo[] pis2 = tt[0].GetProperties(BindingFlags.Public | BindingFlags.Instance);

Respondiendo a @douglas y @ user3524983, lo siguiente debería responder a la pregunta del OP:

    static public IEnumerable<PropertyInfo> GetPropertiesAndInterfaceProperties(this Type type, BindingFlags bindingAttr = BindingFlags.Public | BindingFlags.Instance)
    {
        if (!type.IsInterface) {
            return type.GetProperties( bindingAttr);
        }

        return type.GetInterfaces().Union(new Type[] { type }).SelectMany(i => i.GetProperties(bindingAttr)).Distinct();
    }

o, para una propiedad individual:

    static public PropertyInfo GetPropertyOrInterfaceProperty(this Type type, string propertyName, BindingFlags bindingAttr = BindingFlags.Public|BindingFlags.Instance)
    {
        if (!type.IsInterface) {
            return type.GetProperty(propertyName, bindingAttr);
        }

        return type.GetInterfaces().Union(new Type[] { type }).Select(i => i.GetProperty( propertyName, bindingAttr)).Distinct().Where(propertyInfo => propertyInfo != null).Single();
    }

De acuerdo, la próxima vez lo depuraré antes de publicar en lugar de después :-)

esto funcionó muy bien y concisamente para mí en una carpeta de modelos MVC personalizada. Sin embargo, debería poder extrapolar a cualquier escenario de reflexión. Todavía apesta que es demasiado pasado

    var props =  bindingContext.ModelType.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance).ToList();

    bindingContext.ModelType.GetInterfaces()
                      .ToList()
                      .ForEach(i => props.AddRange(i.GetProperties()));

    foreach (var property in props)