Resumen de aprendizaje 2 de las características de C # (atributo)

Proporcione ejemplos de comportamientos adicionales a través de características: características personalizadas para la validación de datos (valide el tamaño y el no vacío del valor del atributo)

Hay un atributo de QQ en la clase del estudiante. El QQ efectivo no puede ser menor que 100000 (5 dígitos), no puede ser mayor que 999999999999 (12 dígitos), y el atributo QQ no puede estar vacío. Si se cumplen estas validaciones, devuelve verdadero; de lo contrario, devuelve falso.

 

Declare una clase abstracta, todas las características personalizadas heredan de esta clase abstracta, para garantizar que las características personalizadas implementen métodos de validación de datos.

    /// <summary>
    /// 抽象类 基类
    /// </summary>
    public abstract class AbstractVaildDataAttribute : Attribute
    {
        /// <summary>
        /// 验证数据是否符合要求
        /// </summary>
        /// <param name="oValue"></param>
        /// <returns></returns>
        public abstract bool ValidData(object oValue);
    }

 

Declare las características de los atributos de validación no vacíos:

    /// <summary>
    /// 声明一个可以对属性应用 空字符串效验的特性
    /// 效验值是否为空
    /// </summary>
    [AttributeUsage(AttributeTargets.Property)]
    public class RequireAttribute : AbstractVaildDataAttribute
    {
        public override bool ValidData(object oValue)
        {
            return !string.IsNullOrEmpty(oValue.ToString());
        }
    }

 

Declare las características del tamaño del valor del atributo de validación:

    /// <summary>
    /// 声明一个可以对属性应用LongAttribute的特性
    /// 效验值的范围
    /// </summary>
    [AttributeUsage(AttributeTargets.Property)]
    public class LongAttribute : AbstractVaildDataAttribute
    {
        private long _Min = 0;
        private long _Max = 0;

        public LongAttribute(long min, long max)
        {
            _Min = min;
            _Max = max;
        }

        public override bool ValidData(object oValue)
        {
            long lValue = 0;
            return oValue != null && long.TryParse(oValue.ToString(), out lValue) && lValue >= _Min && lValue <= _Max;
        }
    }

 

 Declare una clase de estudiante y agregue dos características personalizadas ('Largo', 'Requerido') sobre los atributos:

 public class Student
    {
        public int Id { get; set; }
        public string Name { get; set; }

        [Long(10000, 999999999999)]
        [Require]
        public long QQ { get; set; }

    }

 

Declare un método de extensión para llamar a la reflexión para verificar el valor de la propiedad:

        /// <summary>
        /// 效验属性的值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public static bool ValidDataExtend<T>(this T t) {
            Type type = t.GetType();
            foreach (var prop in type.GetProperties())
            {
                if (prop.IsDefined(typeof(AbstractVaildDataAttribute),true))
                {
                    object oValue = prop.GetValue(t);//获取要校验类型的值
                    object[] oAttributeArr = prop.GetCustomAttributes(typeof(AbstractVaildDataAttribute), true);//获取所有自定义的特性
                    foreach (AbstractVaildDataAttribute attr in oAttributeArr)
                    {
                        if (!attr.ValidData(oValue))
                        {
                            return false;
                        }
                    }
                }
            }
            return true;
        }

 

Llame al método de extensión para verificar el efecto de la función:

      static void Main(string[] args)
        {
            Student student = new Student()
            {
                Id = 1,
                Name = "张三",
                QQ = 1234565555
            };

            if (student.ValidDataExtend())
            {
                Console.WriteLine("效验通过");
            }
            else
            {
                Console.WriteLine("效验不通过");
            }

            Console.ReadKey();
        }

 Resultados del:

 

Idea de realización general:

1. Declare la clase abstracta (clase base)

2. Declarar características de verificación no vacías y características de verificación de valor numérico 

3. Aplicar características a los atributos

4. Utilice la función de acceso reflectante para verificar si el valor cumple con los requisitos