GetProperties (), um alle Eigenschaften für eine Schnittstellenvererbungshierarchie zurückzugeben

Angenommen, die folgende hypothetische Vererbungshierarchie:

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

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

Reflektion verwenden und folgenden Anruf tätigen:

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

gibt nur die Eigenschaften der Schnittstelle aus IB, die " Name" ist.

Wenn wir einen ähnlichen Test mit dem folgenden Code durchführen würden,

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

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

Der Aufruf typeof(B).GetProperties(BindingFlags.Public | BindingFlags.Instance)gibt ein Array von PropertyInfoObjekten für " ID" und " Name" zurück.

Gibt es eine einfache Möglichkeit, alle Eigenschaften in der Vererbungshierarchie für Schnittstellen wie im ersten Beispiel zu finden?

Ich habe den Beispielcode von @Marc Gravel in eine nützliche Erweiterungsmethode umgewandelt, die sowohl Klassen als auch Schnittstellen kapselt. Außerdem werden zuerst die Schnittstelleneigenschaften hinzugefügt, von denen ich glaube, dass sie das erwartete Verhalten sind.

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 Gibt die abgeflachte Hierarchie zurück, sodass kein rekursiver Abstieg erforderlich ist.

Die gesamte Methode kann mit LINQ viel präziser geschrieben werden:

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

Schnittstellenhierarchien sind ein Schmerz - sie "erben" nicht wirklich als solche, da Sie mehrere "Eltern" haben können (aus Mangel an einem besseren Begriff).

"Abflachen" (wieder nicht ganz der richtige Begriff) Die Hierarchie könnte das Überprüfen aller von der Schnittstelle implementierten Schnittstellen und das Arbeiten von dort aus beinhalten ...

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

Genau das gleiche Problem hat eine hier beschriebene Problemumgehung .

FlattenHierarchy funktioniert übrigens nicht. (nur auf statischen vars. sagt so in Intellisense)

Problemumgehung. Vorsicht vor Duplikaten.

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

Als Antwort auf @douglas und @ user3524983 sollte Folgendes die Frage des OP beantworten:

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

oder für eine einzelne Immobilie:

    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, das nächste Mal werde ich es vor dem Posten debuggen anstatt nach :-)

Dies funktionierte gut und knapp für mich in einem benutzerdefinierten MVC-Modellordner. Sollte jedoch in der Lage sein, auf jedes Reflexionsszenario zu extrapolieren. Immer noch stinkt es irgendwie, dass es zu pass ist

    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)