GetProperties () per restituire tutte le proprietà per una gerarchia di ereditarietà dell'interfaccia

Supponendo la seguente gerarchia di ereditarietà ipotetica:

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

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

Usando la riflessione e facendo la seguente chiamata:

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

restituirà solo le proprietà dell'interfaccia IB, che è " Name".

Se dovessimo fare un test simile sul seguente codice,

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

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

la chiamata typeof(B).GetProperties(BindingFlags.Public | BindingFlags.Instance)restituirà un array di PropertyInfooggetti per " ID" e " Name".

Esiste un modo semplice per trovare tutte le proprietà nella gerarchia di ereditarietà per le interfacce come nel primo esempio?

Ho modificato il codice di esempio di @Marc Gravel in un utile metodo di estensione che incapsula sia le classi che le interfacce. Inoltre aggiunge prima le proprietà dell'interfaccia che credo sia il comportamento previsto.

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 restituisce la gerarchia appiattita, quindi non è necessaria una discesa ricorsiva.

L'intero metodo può essere scritto in modo molto più conciso utilizzando 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());
}

Le gerarchie di interfaccia sono un problema: non "ereditano" in quanto tali, poiché puoi avere più "genitori" (in mancanza di un termine migliore).

"Appiattire" (di nuovo, non è il termine giusto) la gerarchia potrebbe comportare il controllo di tutte le interfacce che l'interfaccia implementa e il lavoro da lì ...

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);
            }
        }
    }
}

Esattamente lo stesso problema ha una soluzione alternativa descritta qui .

FlattenHierarchy non funziona btw. (solo su variabili statiche. dice così in intellisense)

Soluzione. Attenzione ai duplicati.

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

Rispondendo a @douglas e @ user3524983, quanto segue dovrebbe rispondere alla domanda dell'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();
    }

oppure, per una singola proprietà:

    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();
    }

OK la prossima volta che eseguirò il debug prima di postare invece che dopo :-)

questo ha funzionato bene e in modo conciso per me in un raccoglitore di modelli MVC personalizzato. Dovrebbe essere in grado di estrapolare qualsiasi scenario di riflessione però. Ancora una specie di puzza che sia troppo passata

    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)