The Attribute class associates predefined system information or user-defined custom information with a target element. A target element can be an assembly, class, constructor, delegate, enum, event, field, interface, method, portable executable file module, parameter, property, return value, struct, or another attribute.

Information provided by an attribute is also known as metadata. Metadata can be examined at run time by your application to control how your program processes data, or before run time by external tools to control how your application itself is processed or maintained. For example, the .NET Framework predefines and uses attribute types to control run-time behavior, and some programming languages use attribute types to represent language features not directly supported by the .NET Framework common type system.

All attribute types derive directly or indirectly from the Attribute class. Attributes can be applied to any target element; multiple attributes can be applied to the same target element; and attributes can be inherited by an element derived from a target element. Use the AttributeTargets class to specify the target element to which the attribute is applied.

The Attribute class provides convenient methods to retrieve and test custom attributes. For more information about using attributes, see Applying Attributes and Extending Metadata Using Attributes.

public enum Properties
{
    /// <summary>
    /// 血量
    /// </summary>
    HP = 1,

    /// <summary>
    /// 物理攻击
    /// </summary>
    PhyAtk = 2,

    /// <summary>
    /// 物理防御
    /// </summary>
    PhyDef = 3,

    /// <summary>
    /// 法术攻击
    /// </summary>
    MagAtk = 4,

    /// <summary>
    /// 法术防御
    /// </summary>
    MagDef = 5
}

Properties.MagDef返回“法术防御”。

最原始的做法：

public class PropertiesUtils
{
    public static string GetDescByProperties(Properties p)
    {
        switch (p)
        {
            case Properties.HP:
                return "血量";
            case Properties.PhyAtk:
                return "物理攻击";
            case Properties.PhyDef:
                return "物理防御";
            case Properties.MagAtk:
                return "法术攻击";
            case Properties.MagDef:
                return "法术防御";
            default:
                return "未知属性:" + p;
        }
    }
}

这样确实可以解决问题，但是我们可以用Attribute来做的更好。可以做的更好干嘛不呢？

先定义一个用于存储描述文本的Attribute。

[System.AttributeUsage(System.AttributeTargets.Field | System.AttributeTargets.Enum)]
public class PropertiesDesc : System.Attribute
{
    public string Desc { get; private set; }

}
没错，看起来是不是觉得很简单。

public enum Properties
{

    [PropertiesDesc("血量")]
    HP = 1,

    [PropertiesDesc("物理攻击")]
    PhyAtk = 2,

    [PropertiesDesc("物理防御")]
    PhyDef = 3,

    [PropertiesDesc("法术攻击")]
    MagAtk = 4,

    [PropertiesDesc("法术防御")]
    MagDef = 5
}

public class PropertiesUtils
{
    public static string GetDescByProperties(Properties p)
    {
        Type type = p.GetType();
        FieldInfo[] fields = type.GetFields();
        foreach (FieldInfo field in fields)
        {
            if (field.Name.Equals(p.ToString()))
            {
                object[] objs = field.GetCustomAttributes(typeof(PropertiesDesc), true);
                if (objs != null && objs.Length > 0)
                {
                    return ((PropertiesDesc)objs[0]).Desc;
                }
                else
                {
                    return p.ToString() + "没有附加PropertiesDesc信息";
                }
            }
        }
        return "No Such field : "+p;
    }
}

public class PropertiesUtils
{
    private  static Dictionary<Type, Dictionary<string, string>> cache = new Dictionary<Type, Dictionary<string, string>>();

    public static string GetDescByProperties(object p)
    {
        var type = p.GetType();
        if (!cache.ContainsKey(type))
        {
            Cache(type);
        }
        var fieldNameToDesc = cache[type];
        var fieldName = p.ToString();
        return fieldNameToDesc.ContainsKey(fieldName) ? fieldNameToDesc[fieldName] : string.Format("Can not found such desc for field `{0}` in type `{1}`", fieldName, type.Name);
    }

    private static void Cache(Type type)
    {
        var dict = new Dictionary<string, string>();
        cache.Add(type, dict);
        var fields = type.GetFields();
        foreach (var field in fields)
        {
            var objs = field.GetCustomAttributes(typeof(PropertiesDesc), true);
            if (objs.Length > 0)
            {
                dict.Add(field.Name, ((PropertiesDesc)objs[0]).Desc);
            }
        }
    }
}

3、还能干什么？