Como obter uma lista de propriedades com um determinado atributo?

Eu tenho um tipo, te eu gostaria de obter uma lista das propriedades públicas que tenham o atributo MyAttribute. O atributo é marcado com AllowMultiple = false, assim:

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

Atualmente, o que tenho é isso, mas estou pensando que há uma maneira melhor:

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

Como posso melhorar isso? Peço desculpas se esta é uma duplicata, há uma tonelada de tópicos de reflexão por aí ... parece que é um assunto bastante quente.

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

Isso evita a necessidade de materializar quaisquer instâncias de atributo (ou seja, é mais barato que GetCustomAttribute[s]().

A solução que eu mais uso é baseada na resposta de Tomas Petricek. Normalmente, eu quero fazer algo com tanto o atributo e propriedade.

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

Até onde eu sei, não há maneira melhor de trabalhar com a biblioteca Reflection de maneira mais inteligente. No entanto, você pode usar o LINQ para tornar o código um pouco melhor:

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'

Acredito que isso ajude você a estruturar o código de maneira mais legível.

Sempre há LINQ:

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

Se você lida regularmente com Atributos em reflexão, é muito, muito prático definir alguns métodos de extensão. Você verá isso em muitos projetos por aí. Este aqui é um que eu geralmente tenho:

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

que você pode usar como typeof(Foo).HasAttribute<BarAttribute>();

Outros projetos (por exemplo, StructureMap) possuem classes ReflectionHelper de pleno direito que usam árvores de Expressão para ter uma sintaxe fina de identidade, por exemplo, PropertyInfos. O uso fica assim:

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

Além das respostas anteriores: é melhor usar o método Any()do que verificar o tamanho da coleção:

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

O exemplo em dotnetfiddle: https://dotnetfiddle.net/96mKep