20181114_特性

一.   特性:

比如下图中的Obsolete是特性, CustomAttribute是特性(自定义的特性), Serializable也是特性

二.    特性的作用:

a)         特性的核心作用:补充; 就像反射的核心作用一样: 动态

b)         影响编译器的运行; [Obsolete("请不要使用这个了，请使用什么来代替", true)]如果是true则引用的时候, 编译器会报错

c)         影响程序的运行; 比如[Serializable]表示某个类是否可以序列化和反序列化

　　　　　　对于上图中标记的特性的说明:

　　　　　　[Obsolete("请不要使用这个了，请使用什么来代替", true)]//影响编译器的运行 ; 这个特性一般用在api升级的时候; 比如1.0中有一个函数叫getProductinfo(),

　　　　　　那么2.0中对此函数进行了升级getProductinfo(string shopId); 那么可以在API中对1.0中的getProductinfo()函数上面添加此特性; 在调用的时候就会有这样的提示

     　　　　  [Serializable]//可以序列化和反序列化  可以影响程序的运行

d)         特性就是一个类, 继承自attribute, 一般以Attribute结尾, 在标记的时候和声明时候都可以省略掉, 因为特性本身就是一个类, 那么它当然可以包含属性/字段/方法/委托/事件

e)         自定义的特性一般以Attribute结尾，声明时(使用时) 可以省略掉Attribute

f)          当使用特性进行修饰元素的时候, 默认只能修饰一次, 如果需要多次修饰的话, 要在定义此特性的类上增加 

　　　　　　[AttributeUsage(AttributeTargets.All, AllowMultiple = true)] 　　　　　　

　　　　　　//AllowMultiple = true默认值为false; 通常也不推荐修改为true, 一般使用默认值即可

 

g)        AttributeUsage是一个专门用来修饰特性的一个特性类, 它用来描述, 某个特性类, 可以用在什么地方(类上-方法上-属性上)/是否可以叠加使用/是否可以被继承等. . .

h)  　　 [AttributeUsage(AttributeTargets.Class,  AllowMultiple = true)]

　　　　AttributeTargets 是一个枚举; 指定class表示只能修饰类  ; 指定Method则表示修饰方法

　　　　AttributeTargets.All|AttributeTargets.Method

　　　　Inherited = true表示此特性是否可以被继承

 

i)  特性可以添加到方法上/类上/属性上/返回值上

 [CustomAttribute] //属性添加特性
     public int Id { get; set; }

        [Custom()] //给方法添加特性
        [return: Custom()] //给返回值添加一个特性; 很少见
        public string Answer([Custom]string name) //给参数添加特性
        {
            return $"This is {name}";
        }

j) 特性, 本身是没用的 , 任何一个生效的特性,都是因为其它地方的主动使用; 没有破坏类型封装的前提下，可以加点额外的信息和行为, 但是这是有前提的, 也就是说必须通过反射才行, 因为给一个元素上特性添加后，编译器会在元素内部标记元数据, 可以通过IL(中间语言)查看, 但是元数据我们是没办法直接使用的, 只有通过反射来调用 ; 如果不用调用, 特性相当于就没有用

三.   创建自定义的特性类, 代码如下:

/// <summary>
    /// 检查数字是否在指定范围内的特性, 这个特性在使用的时候, 需要传递两个参数, 且都是long类型的
    /// </summary>
    public class LongAttribute : Attribute //自定义特性类, 必须继承Attribute
    {
        private long _Min = 0;
        private long _Max = 0;
        public LongAttribute(long min, long max)
        {
            this._Min = min;
            this._Max = max;
        }

        public  bool Validate(object value)//" "
        {
            if (value != null && !string.IsNullOrWhiteSpace(value.ToString()))
            {
                //检查value是不是long类型, 如果是, 则复制给lResult; 
                if (long.TryParse(value.ToString(), out long lResult))
                {
                    if (lResult > this._Min && lResult < this._Max)
                    {
                        return true;
                    }
                }
            }
            return false;
        }
    }

四.   特性基本说明:

a)   简单介绍, Custom是在上面自定义的那个特性类:

　　[Custom]

     [Custom()]//调用空的构造函数, 以上两种写法效果一样

     //这种写法就等于在实例化一个类

     [Custom(123), Custom(123, Description = "1234")]

    //这里要注意, 如果是构造函数的参数, 可以直接传递, 如果是字段, 则必须使用 字段名=值 的格式

 [Custom(123, Description = "1234", Remark = "2345")]//方法不行

五.   使用反射将枚举值转变成字符, 要达到的效果如下图; 

 

a)         定义特性类RemarkAttribute, 代码如下:

 /// <summary>
    /// 自定义特性类; 特性类必须继承   Attribute
    /// </summary>
    public class RemarkAttribute : Attribute //特性的类的后缀Attribute, 是可以省略的; 但是只有在使用的时候可以省略
    {
        private string _Remark = null;
        public RemarkAttribute(string remark)
        {
            this._Remark = remark;
        } 
        public string GetRemark()
        {
            return this._Remark;
        }
    }

b) 对Enum类型进行反射取值, 直接使用对枚举扩展的方法来操作, 定义枚举扩展类RemarkExtension:

/// <summary>
    /// 查找特性的类, 这个类仅仅对枚举类型进行了扩展
    /// </summary>
    public static class RemarkExtension
    {
        /// <summary>
        /// 由于添加了this, 那么这是一个扩展方法, 任何枚举都可以调用这个方法
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static string GetRemark(this Enum value) //对枚举进行扩展
        {
            //根据传递的值得到一个枚举类型
            Type type = value.GetType();
            //找出对应的字段; 枚举中定义的都是字段, 而不是属性
            FieldInfo field = type.GetField(value.ToString());
            //判断该字段上是不是打有 Remark特性
            if (field.IsDefined(typeof(RemarkAttribute), true))
            {
                RemarkAttribute attribute = (RemarkAttribute)field.GetCustomAttribute(typeof(RemarkAttribute), true);
                return attribute.GetRemark();
            }
            else
            {
                return value.ToString();
            }
        }
    }

c) UserState的枚举类代码

/// <summary>
    /// 用户状态; 绑定界面属性; 在webForm时代, 最常见的就是 用户名: textbox   密码: textbox
    /// 那么通过特性, 用户名  这样的字符串都可以是动态的
    /// </summary>
    public enum UserState
    {
        /// <summary>
        /// 正常
        /// </summary>
        [Remark("正常")]  //使用特性; 特性类在下面
        Normal = 0,//左边是字段名称(Normal),右边是数据库值(0),哪里放描述?也就是说要在界面上展示的 正常 字符
        /// <summary>
        /// 冻结
        /// </summary>
        [Remark("冻结")]
        Frozen = 1,
        /// <summary>
        /// 删除
        /// </summary>
        //[Remark("删除")]
        Deleted = 2
    }

 d)  调用方法:

#region 通过特性为字段/属性/成员添加一些信息

    UserState userState = UserState.Normal;
    if (userState == UserState.Normal)
    {
        Console.WriteLine("正常状态"); //界面绑定一个中文
    }
    else if (userState == UserState.Frozen)
    { }
    else
    { }

   //GetRemark()方法是个扩展了Enum的方法; 任何定义个枚举都可以调用
    Console.WriteLine(userState.GetRemark());
    //常规的调用方法
    Console.WriteLine(RemarkExtension.GetRemark(userState));
    
    #endregion

　六. 通过扩展object类, 检查属性的合法性, 属性的值是否在指定范围之内　

　a) 自定义的抽象特性类:

 /// <summary>
    /// 抽象类, 每一个需要约束的方法都继承此类
    /// </summary>
    public abstract class AbstractValidateAttribute : Attribute
    {
        public abstract bool Validate(object value);
    }

　b)  字符长度的校验类, 继承抽象类 AbstractValidateAttribute:

/// <summary>
    /// 只能让他修饰属性和字段; 检查字符串长度的特性
    /// </summary>
    [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
    public class LengAttribute : AbstractValidateAttribute
    {
        private int _Min = 0;
        private int _Max = 0;

        /// <summary>
        /// 特性类的构造函数
        /// </summary>
        /// <param name="min"></param>
        /// <param name="max"></param>
        public LengAttribute(int min, int max)
        {
            this._Min = min;
            this._Max = max;
        }


        public override bool Validate(object value)//" "
        {
            //return value != null && !string.IsNullOrWhiteSpace(value.ToString()) && value.ToString().Length >  _Min && value.ToString().Length <  _Max;
            if (value != null && !string.IsNullOrWhiteSpace(value.ToString()))
            {
                int length = value.ToString().Length;
                if (length > this._Min && length < this._Max)
                {
                    return true;
                }
            }
            return false;
        }
    }

 c) 检查数字是否在指定范围内, 继承抽象类AbstractValidateAttribute:

/// <summary>
    /// 检查数字是否在指定范围内的特性, 这个特性在使用的时候, 需要传递两个参数, 且都是long类型的
    /// </summary>
   [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
    public class LongAttribute : AbstractValidateAttribute
    {
        private long _Min = 0;
        private long _Max = 0;
        public LongAttribute(long min, long max)
        {
            this._Min = min;
            this._Max = max;
        }


        public override bool Validate(object value)//" "
        { 
            if (value != null && !string.IsNullOrWhiteSpace(value.ToString()))
            {
                //检查value是不是long类型, 如果是, 则复制给lResult; 
                if (long.TryParse(value.ToString(), out long lResult))
                {
                    if (lResult > this._Min && lResult < this._Max)
                    {
                        return true;
                    }
                }
            }
            return false;
        }
    }

d) 扩展object类, 注意由于是扩展的object类, 那么所有的类型都将具有这个方法:

/// <summary>
    /// 验证扩展类
    /// </summary>
    public static class ValidateExtension
    {
        /// <summary>
        /// 验证扩展
        /// </summary>
        /// <param name="oObject"></param>
        /// <returns></returns>
        public static bool Validate(this object oObject)
        {
            Type type = oObject.GetType();
            foreach (var prop in type.GetProperties())
            {
              //检查prop上是不是有这个 抽象 的特性, 这个抽象当前派生了两个类, 如果有需要则可以继续进行派生, 但是此类就无需再修改, 当然如果想要报错更清晰一点, 可以修改此类
                if (prop.IsDefined(typeof(AbstractValidateAttribute), true))
                {
                    object[] attributeArray = prop.GetCustomAttributes(typeof(AbstractValidateAttribute), true);
                    foreach (AbstractValidateAttribute attribute in attributeArray)
                    {
                        if (!attribute.Validate(prop.GetValue(oObject)))
                        {
                            return false;
                        }
                    }
                }
                 
            }
            return true;
        }
    }

e) 需要校验属性的类, 这里使用student类进行模拟校验:　　

public class Student
    { 
        /// <summary>
        /// 相当于调用了Leng这个特性类的构造函数
        /// </summary>
        [Leng(5, 10)] 
        public string Name { get; set; }

        [Extension.Leng(20, 50)]
        public string Accont { get; set; }

        /// <summary>
        /// 10001~999999999999
        /// </summary>
        [Long(10001, 999999999999)]
        public long QQ { get; set; } 
    }

f)    调用方式; 还是那一句→所有的特性都要主动去调用:

      由于特性是基于object扩展的, 所以任何类都可以主动去使用

 Student student = new Student();
            
student.Name = "孙悟空";
student.QQ = 123456;
student.Accont = "23434234243323";
student.Validate();