Wie erhalte ich eine Liste von Eigenschaften mit einem bestimmten Attribut?

Ich habe einen Typ, t und möchte eine Liste der öffentlichen Eigenschaften erhalten, die das Attribut haben MyAttribute. Das Attribut ist AllowMultiple = falsewie folgt gekennzeichnet :

[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]

Momentan habe ich Folgendes, aber ich denke, es gibt einen besseren Weg:

foreach (PropertyInfo prop in t.GetProperties())
{
    object[] attributes = prop.GetCustomAttributes(typeof(MyAttribute), true);
    if (attributes.Length == 1)
    {
         //Property with my custom attribute
    }
}

Wie kann ich das verbessern? Ich entschuldige mich, wenn dies ein Duplikat ist, gibt es da draußen eine Menge Reflexionsfäden ... scheint ein ziemlich heißes Thema zu sein.

var props = t.GetProperties().Where(
                prop => Attribute.IsDefined(prop, typeof(MyAttribute)));

Dadurch wird vermieden, dass Attributinstanzen materialisiert werden müssen (dh es ist billiger als GetCustomAttribute[s]().

Die Lösung, die ich am häufigsten verwende, basiert auf der Antwort von Tomas Petricek. Normalerweise möchte ich sowohl mit dem Attribut als auch mit der Eigenschaft etwas tun .

var props = from p in this.GetType().GetProperties()
            let attr = p.GetCustomAttributes(typeof(MyAttribute), true)
            where attr.Length == 1
            select new { Property = p, Attribute = attr.First() as MyAttribute};

Soweit ich weiß, gibt es keinen besseren Weg, um mit der Reflection-Bibliothek intelligenter zu arbeiten. Sie können jedoch LINQ verwenden, um den Code ein bisschen schöner zu machen:

var props = from p in t.GetProperties()
            let attrs = p.GetCustomAttributes(typeof(MyAttribute), true)
            where attrs.Length != 0 select p;

// Do something with the properties in 'props'

Ich glaube, dies hilft Ihnen, den Code besser lesbar zu strukturieren.

Es gibt immer LINQ:

t.GetProperties().Where(
    p=>p.GetCustomAttributes(typeof(MyAttribute), true).Length != 0)

Wenn Sie sich regelmäßig mit Attributen in Reflection beschäftigen, ist es sehr, sehr praktisch, einige Erweiterungsmethoden zu definieren. Sie werden das in vielen Projekten sehen. Dieser hier ist einer, den ich oft habe:

public static bool HasAttribute<T>(this ICustomAttributeProvider provider) where T : Attribute
{
  var atts = provider.GetCustomAttributes(typeof(T), true);
  return atts.Length > 0;
}

die du gerne benutzen kannst typeof(Foo).HasAttribute<BarAttribute>();

Andere Projekte (z. B. StructureMap) verfügen über vollwertige ReflectionHelper-Klassen, die Ausdrucksbäume verwenden, um eine feine Syntax für die Identität zu erhalten, z. B. PropertyInfos. Die Verwendung sieht dann so aus:

ReflectionHelper.GetProperty<Foo>(x => x.MyProperty).HasAttribute<BarAttribute>()

Zusätzlich zu den vorherigen Antworten: Es ist besser, die Methode zu verwenden, Any()anstatt die Länge der Sammlung zu überprüfen:

propertiesWithMyAttribute = type.GetProperties()
  .Where(x => x.GetCustomAttributes(typeof(MyAttribute), true).Any());

Das Beispiel bei dotnetfiddle: https://dotnetfiddle.net/96mKep