Comment accéder à l'attribut Description sur une propriété ou une const en C #?

Comment accédez-vous à la Description de la propriété sur un const ou une propriété, c'est à dire,

public static class Group
{

    [Description( "Specified parent-child relationship already exists." )]
    public const int ParentChildRelationshipExists = 1;

    [Description( "User is already a member of the group." )]
    public const int UserExistsInGroup = 2;

}

public static class Group
{

    [Description( "Specified parent-child relationship already exists." )]
    public static int ParentChildRelationshipExists { 
      get { return 1; } 
    }

    [Description( "User is already a member of the group." )]
    public static int UserExistsInGroup { 
      get { return 2; } 
    }

}

Dans l'appel de la classe, j'aimerais accéder à la Description des biens, c'est à dire,

int x = Group.UserExistsInGroup;
string description = Group.UserExistsInGroup.GetDescription(); //or similar

Je suis ouvert à des idées à d'autres méthodes.

EDIT:
Je devrais avoir mentionné le fait que j'ai vu un exemple fourni ici:
Ne les propriétés implémentées automatiquement soutien attributs?

Cependant, je suis à la recherche d'une méthode pour accéder à la description de l'attribut sans avoir à entrer un littéral chaîne dans le type de propriété, c'est à dire, je préfère ne pas le faire:

typeof(Group).GetProperty("UserExistsInGroup");

Quelque chose le long des lignes d'une Méthode d'Extension; similaire à la méthode suivante qui sera de retour de l'attribut de Description sur un Enum via une Méthode d'Extension:

public static String GetEnumDescription( this Enum obj )
{
    try
    {
        System.Reflection.FieldInfo fieldInfo = 
            obj.GetType().GetField( obj.ToString() );

        object[] attribArray = fieldInfo.GetCustomAttributes( false );

        if (attribArray.Length > 0)
        {
            var attrib = attribArray[0] as DescriptionAttribute;

            if( attrib != null  )
                return attrib.Description;
        }
        return obj.ToString();
    }
    catch( NullReferenceException ex )
    {
        return "Unknown";
    }
}

source d'informationauteur Metro Smurf | 2009-03-30

4

Vous pouvez appeler MemberInfo.GetCustomAttributes() pour obtenir tous les attributs définis sur un membre d'un Type. Vous pouvez obtenir le MemberInfo pour le bien en faisant quelque chose comme ceci:
```
PropertyInfo prop = typeof(Group).GetProperty("UserExistsInGroup",
    BindingFlags.Public | BindingFlags.Static);
```

Essayez ce qui suit

var property = typeof(Group).GetProperty("UserExistsInGroup");
var attribute = property.GetCustomAttributes(typeof(DescriptionAttribute), true)[0];
var description = (DescriptionAttribute)attribute;
var text = description.Description;

Ok, j'ai vu ton edit, je ne suis pas sûr que vous pouvez le faire avec des méthodes d'extension, comme ils le seraient anaware du type de la classe conteneur.

Cela va sembler un peu farfelu, mais comment sur la création d'une nouvelle classe d'un "DescribedInt", qui aurait implicite de l'opérateur de cast pour vous permettre de l'utiliser comme un int automatiquement? Vous serez en mesure d'utiliser à peu près comment vous le décrire. Vous aurez toujours une description, mais quand vous avez besoin de l'utiliser comme un Int, vous ne besoin pour obtenir le .Les données de propriété...

par exemple:

private void ExampleUse()
{
    int myvalue = Group.A; //see, no need to cast or say ".Data" - implicit cast
    string text = Group.A.Description;

//faire quelque chose avec des valeurs...
}

public static class Group
{
    public static DescribedInt A = new DescribedInt(12, "some description");
    public static DescribedInt B = new DescribedInt(88, "another description");
}

public class DescribedInt
{
    public readonly int data;
    public readonly string Description;

    public DescribedInt(int data, string description)
    {
        this.data = data;
        this.Description = description;
    }

    //automatic cast to int
    public static implicit operator int(DescribedInt orig)
    {
        return orig.data;
    }

    //public DescribedInt(string description)
    //{
    //   this.description = description;
    //}

    //if you ever need to go the "other way"
    //public static implicit operator DescribedInt(int orig)
    //{
    //   return new DescribedInt(orig, "");
    //}
}

Ici est une classe d'assistance que j'utilise pour le traitement des attributs personnalisés .NET

public class AttributeList : List<Attribute>
{
    ///<summary>
    ///Gets a list of custom attributes
    ///</summary>
    ///<param name="propertyInfo"></param>
    ///<returns></returns>
    public static AttributeList GetCustomAttributeList(ICustomAttributeProvider propertyInfo)
    {
        var result = new AttributeList();
        result.AddRange(propertyInfo.GetCustomAttributes(false).Cast<Attribute>());
        return result;
    }

    ///<summary>
    ///Finds attribute in collection by its type
    ///</summary>
    ///<typeparam name="T"></typeparam>
    ///<returns></returns>
    public T FindAttribute<T>() where T : Attribute
    {
        return (T)Find(x => typeof(T).IsAssignableFrom(x.GetType()));
    }

    public bool IsAttributeSet<T>() where T : Attribute
    {
        return FindAttribute<T>() != null;
    }
}

Également des tests unitaires pour MsTest montrant comment utiliser cette classe

[TestClass]
public class AttributeListTest
{
    private class TestAttrAttribute : Attribute
    {
    }

    [TestAttr]
    private class TestClass
    {
    }

    [TestMethod]
    public void Test()
    {
        var attributeList = AttributeList.GetCustomAttributeList(typeof (TestClass));
        Assert.IsTrue(attributeList.IsAttributeSet<TestAttrAttribute>());
        Assert.IsFalse(attributeList.IsAttributeSet<TestClassAttribute>());
        Assert.IsInstanceOfType(attributeList.FindAttribute<TestAttrAttribute>(), typeof(TestAttrAttribute));
    }
}

http://www.kozlenko.info/2010/02/02/getting-a-list-of-custom-attributes-in-net/

Vous devez vous connecter pour publier un commentaire.