229

Given a property in a class, with attributes - what is the fastest way to determine if it contains a given attribute? For example:

    [IsNotNullable]
    [IsPK]
    [IsIdentity]
    [SequenceNameAttribute("Id")]
    public Int32 Id
    {
        get
        {
            return _Id;
        }
        set
        {
            _Id = value;
        }
    }

What is the fastest method to determine that for example it has the "IsIdentity" attribute?

8 Answers 8

362

There's no fast way to retrieve attributes. But code ought to look like this (credit to Aaronaught):

var t = typeof(YourClass);
var pi = t.GetProperty("Id");
var hasIsIdentity = Attribute.IsDefined(pi, typeof(IsIdentity));

If you need to retrieve attribute properties then

var t = typeof(YourClass);
var pi = t.GetProperty("Id");
var attr = (IsIdentity[])pi.GetCustomAttributes(typeof(IsIdentity), false);
if (attr.Length > 0) {
    // Use attr[0], you'll need foreach on attr if MultiUse is true
}
4
  • 77
    If you only need to check for the existence of the attribute, and not retrieve any information from it, using Attribute.IsDefined will eliminate one line of code and the ugly arrays/casting.
    – Aaronaught
    Commented Jan 12, 2010 at 18:42
  • 5
    Something I just ran into with this is some attributes have a different type to their attribute name. For example "NotMapped" in System.ComponentModel.DataAnnotations.Schema is used as [NotMapped] in the class but to detect it you have to use Attribute.IsDefined(pi, typeof(NotMappedAttribute))
    – Qjimbo
    Commented Jul 13, 2018 at 21:41
  • 2
    Might be easier to use the generic overload: IsIdentity[] attr = pi.GetCustomAttributes<IsIdentity>(false);
    – Mojtaba
    Commented Mar 28, 2019 at 11:27
  • 1
    @Qjimbo (or probably someone else reading) Attributes are usually used without the "Attribute" part of their name, but can be. A convention allows you to exclude it, so usually the actual type does have Attribute at the end of its name, but is just not used.
    – Jim Wolff
    Commented Mar 13, 2020 at 20:29
50

If you are using .NET 3.5 you might try with Expression trees. It is safer than reflection:

class CustomAttribute : Attribute { }

class Program
{
    [Custom]
    public int Id { get; set; }

    static void Main()
    {
        Expression<Func<Program, int>> expression = p => p.Id;
        var memberExpression = (MemberExpression)expression.Body;
        bool hasCustomAttribute = memberExpression
            .Member
            .GetCustomAttributes(typeof(CustomAttribute), false).Length > 0;
    }
}

This is safer because it is tied to the property Id itself. If the property's name changes, this fails in compile time.

Whereas reflection is tied to a string "Id" which will not fail to compile if the property's name changes, and will only fail when executing that code.
Modern versions of C# can avoid this by using nameof(MyClass.Id) for reflection, instead of "Id".

1
24

This can now be done without expression trees and extension methods in a type safe manner with the new C# feature nameof() like this:

Attribute.IsDefined(typeof(YourClass).GetProperty(nameof(YourClass.Id)), typeof(IsIdentity));

nameof() was introduced in C# 6

0
17

You can use the Attribute.IsDefined method

https://msdn.microsoft.com/en-us/library/system.attribute.isdefined(v=vs.110).aspx

if(Attribute.IsDefined(YourProperty,typeof(YourAttribute)))
{
    //Conditional execution...
}

You could provide the property you're specifically looking for or you could iterate through all of them using reflection, something like:

PropertyInfo[] props = typeof(YourClass).GetProperties();
3
  • This doesn't compile. You can't use [] around YourProperty or YourAttribute
    – rollsch
    Commented Sep 4, 2018 at 6:22
  • Every previous answer has used assumptions on class, property and attribute names which I followed. Commented Sep 12, 2018 at 18:14
  • Appears fixed now.
    – rollsch
    Commented Sep 17, 2018 at 2:22
15

You can use a common (generic) method to read attribute over a given MemberInfo

public static bool TryGetAttribute<T>(MemberInfo memberInfo, out T customAttribute) where T: Attribute {
                var attributes = memberInfo.GetCustomAttributes(typeof(T), false).FirstOrDefault();
                if (attributes == null) {
                    customAttribute = null;
                    return false;
                }
                customAttribute = (T)attributes;
                return true;
            }
8

To update and/or enhance the answer by @Hans Passant I would separate the retrieval of the property into an extension method. This has the added benefit of removing the nasty magic string in the method GetProperty()

public static class PropertyHelper<T>
{
    public static PropertyInfo GetProperty<TValue>(
        Expression<Func<T, TValue>> selector)
    {
        Expression body = selector;
        if (body is LambdaExpression)
        {
            body = ((LambdaExpression)body).Body;
        }
        switch (body.NodeType)
        {
            case ExpressionType.MemberAccess:
                return (PropertyInfo)((MemberExpression)body).Member;
            default:
                throw new InvalidOperationException();
        }
    }
}

Your test is then reduced to two lines

var property = PropertyHelper<MyClass>.GetProperty(x => x.MyProperty);
Attribute.IsDefined(property, typeof(MyPropertyAttribute));
8

If you are trying to do that in a Portable Class Library PCL (like me), then here is how you can do it :)

public class Foo
{
   public string A {get;set;}

   [Special]
   public string B {get;set;}   
}

var type = typeof(Foo);

var specialProperties = type.GetRuntimeProperties()
     .Where(pi => pi.PropertyType == typeof (string) 
      && pi.GetCustomAttributes<Special>(true).Any());

You can then check on the number of properties that have this special property if you need to.

2

This is a pretty old question but I used

My method has this parameter but it could be built:

Expression<Func<TModel, TValue>> expression

Then in the method this:

System.Linq.Expressions.MemberExpression memberExpression 
       = expression.Body as System.Linq.Expressions.MemberExpression;
Boolean hasIdentityAttr = System.Attribute
       .IsDefined(memberExpression.Member, typeof(IsIdentity));

Not the answer you're looking for? Browse other questions tagged or ask your own question.