特性应用

特性：是一个类，用来标记元素，编译时生成到metadata里面，平时不影响程序的运行，除非主动用反射区查找，能够获得一些额外的信息/操做，提供了更丰富的扩展空间。

示例代码以下：

class Program
    {
        static void Main(string[] args)
        {
            ///获取枚举描述
            {
                string userState = UserState.Frozen.GetRemark();
                Console.WriteLine(userState);
            }
            //校验数据
            {
                Student student = new Student() { Score = 90 };
                bool b = DataVaildate.Validate<Student>(student);
                student.Score = -1;
                b = DataVaildate.Validate<Student>(student);
            }
            Console.ReadKey();
        }
    }
    /// <summary>
    /// 扩展方法
    ///     一、静态类
    ///     二、静态方法
    ///     三、第一个参数类型前加this
    /// </summary>
    public static class EnumExtend
    {
        public static string GetRemark(this Enum enumValue)
        {
            Type type = enumValue.GetType();
            FieldInfo fieldInfo = type.GetField(enumValue.ToString());
            if (fieldInfo.IsDefined(typeof(RemarkAttribute), true))
            {
                RemarkAttribute remarkAttribute = (RemarkAttribute)fieldInfo.GetCustomAttribute(typeof(RemarkAttribute), true);
                return remarkAttribute.Remark;
            }
            else
            {
                return enumValue.ToString();
            }
        }
    }
    [AttributeUsage(AttributeTargets.Field, AllowMultiple = false, Inherited = true)]//修饰特性的特性
    public class RemarkAttribute : Attribute//Remark特性
    {
        public string Remark { get; private set; }
        public RemarkAttribute(string remark)
        {
            this.Remark = remark;
        }
    }
    /// <summary>
    /// 校验特性的父类
    /// </summary>
    public abstract class AbstractValidateAttribute : Attribute
    {
        public abstract bool Validate(object oValue);
    }
    /// <summary>
    /// Long取值范围校验特性
    /// </summary>
    public class LongValidateAttribute : AbstractValidateAttribute
    {
        private long _lMin = 0;//最小值
        private long _lMax = 0;//最大值

        public LongValidateAttribute(long lMin, long lMax)
        {
            this._lMin = lMin;
            this._lMax = lMax;
        }
        public override bool Validate(object oValue)
        {
            return this._lMin <= (long)oValue && (long)oValue <= this._lMax;
        }
    }
    public enum UserState
    {
        [Remark("正常")]
        Normal = 0,
        [Remark("冻结")]
        Frozen = 1,
        [Remark("删除")]
        Deleted = 2
    }
    public class Student
    {
        [LongValidate(0, 100)]
        public long Score { get; set; }
    }

    public class DataVaildate
    {
        public static bool Validate<T>(T t)
        {
            Type type = t.GetType();//获取传入参数的类型
            foreach (var prop in type.GetProperties())//遍历属性
            {
                if (prop.IsDefined(typeof(AbstractValidateAttribute), true))//判断属性是否认义了校验的特性
                {
                    AbstractValidateAttribute abstractValidateAttribute = (AbstractValidateAttribute)prop.GetCustomAttribute(typeof(AbstractValidateAttribute), true);//获取到须要校验的特性
                    if (!abstractValidateAttribute.Validate(prop.GetValue(t)))//校验
                    {
                        return false;
                    }
                }
            }
            return true;
        }
    }