C# 基础知识-特性

C基础 - 特性

一.特性

1>特性本质就是一个类，直接或者间接的继承了Attribute

2>特性就是在不破话类封装的前提下，加点额外的信息或者行为

二.应用场景之-枚举上加描述

运行结果如下图

using System;
using System.Reflection;

namespace ConsoleApp1
{
    public enum RunState
    {
        [RemarkEnum(Remark = "正在运行")]
        Running = 0,

        [RemarkEnum(Remark = "停止")]
        Stop = 1,

        [RemarkEnum(Remark = "完成")]
        Finish = 2,
    }
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(RunState.Running.GetRemark());
            Console.WriteLine(RunState.Stop.GetRemark());
            Console.WriteLine(RunState.Finish.GetRemark());
            Console.ReadKey();
        }
    }
    public class RemarkEnumAttribute : Attribute
    {
        public string Remark { get; set; }
    }
    /// <summary>
    /// 扩展方法：静态类，静态方法，this这三个部分造成
    /// 调用的时候，直接对象.方法名
    /// </summary>
    public static class RemarkExtend
    {
        public static string GetRemark(this Enum enumValue)
        {
            Type type = enumValue.GetType();
            FieldInfo field = type.GetField(enumValue.ToString());
            if (field.IsDefined(typeof(RemarkEnumAttribute), true))
            {
                RemarkEnumAttribute attribute = (RemarkEnumAttribute)field.GetCustomAttribute(typeof(RemarkEnumAttribute), true);
                return attribute.Remark;
            }
            else
            {
                return enumValue.ToString();
            }
        }
    }
}

三.应用场景值之-结构体加描述

运行结果如下图

using System;
using System.Reflection;

namespace ConsoleApp1
{
    public struct CommPara
    {
        [StructExten(Remark = "串口号")]
        public string CommPort;
        [StructExten(Remark = "Id号")]
        public int Id;
    }
    class Program
    {
        static void Main(string[] args)
        {
            CommPara comm = new CommPara()
            {
                CommPort = "Com1",
                Id = 10,
            };
            Console.WriteLine(comm.GetRemark());
            Console.ReadKey();
        }
    }

    [AttributeUsage(AttributeTargets.Struct | AttributeTargets.Field)]
    public class StructExtenAttribute : Attribute
    {
        public string Remark { get; set; }
    }
    public static class RemarkStructExtend
    {
        public static string GetRemark(this object enumValue)
        {
            string Name = string.Empty;
            Type type = enumValue.GetType();
            FieldInfo[] fields = type.GetFields();
            foreach (var field in fields)
            {
                if (field.IsDefined(typeof(StructExtenAttribute), true))
                {
                    StructExtenAttribute attribute = (StructExtenAttribute)field.GetCustomAttribute(typeof(StructExtenAttribute), true);
                    Name += $"{ attribute.Remark},";
                }
                else
                {
                    Name = enumValue.ToString();
                }
            }
            return Name;
        }
    }
}

四.访问类，属性，方法上的特性，另外特性上加一些验证行为

调用实例如下：

首先控制台项目中，添加Student类，Manager类，Validate特性类，这些类见下面，添加好后如下图显示的：

 

using System;

namespace _002_Attribute
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Student student = new Student()
                {
                    Name = "小王",
                    Id = 100,
                    QQ = 10002,
                };
                Manager.Show<Student>(student);
                Console.ReadKey();
            }
            catch (Exception ex)
            {

            }
        }
    }
}

运行结果如下图

Student类

using System;

namespace _002_Attribute
{
    [Remark(Description = "学生")]
    public class Student
    {
        [Length(1, 5)]
        [Remark(Description = "我是Name")]
        public string Name { get; set; }

        [Remark(Description = "学生的Id")]
        public int Id { get; set; }


        [Long(10001, 999999)]
        public int QQ { get; set; }

        [Remark(Description = "我在学习")]
        public void Study([Remark]string name)
        {
            Console.WriteLine($"{name} study now!");
        }
    }
}

Manager类：只要是程序运行的时候，使用特性

using System;
using System.Reflection;

namespace _002_Attribute
{
    public class Manager
    {
        public static void Show<T>(T student)
        {
            Type type = typeof(T);
            //访问类的特性
            if (type.IsDefined(typeof(RemarkAttribute), true))//类访问特性
            {
                RemarkAttribute reamrk = (RemarkAttribute)type.GetCustomAttribute(typeof(RemarkAttribute), true);
                Console.WriteLine($"我是类上的特性：{reamrk.Description}");
                reamrk.Show();
            }

            Console.WriteLine("******************************************************************");
            //访问Id属性的特性
            PropertyInfo property = type.GetProperty("Id");
            if (property.IsDefined(typeof(RemarkAttribute), true))
            {
                RemarkAttribute remark = (RemarkAttribute)property.GetCustomAttribute(typeof(RemarkAttribute), true);
                Console.WriteLine($"我是属性的特性：{remark.Description}");
                remark.Show();
            }
            Console.WriteLine("******************************************************************");
            //访问所有属性的特性
            PropertyInfo[] propertys = type.GetProperties();
            foreach (var prop in propertys)
            {
                if (prop.IsDefined(typeof(RemarkAttribute), true))
                {
                    RemarkAttribute remark = (RemarkAttribute)prop.GetCustomAttribute(typeof(RemarkAttribute), true);
                    Console.WriteLine($"我是属性的特性：{remark.Description}");
                }
            }

            Console.WriteLine("******************************************************************");
            //访问方法的特性
            MethodInfo method = type.GetMethod("Study");
            if (method.IsDefined(typeof(RemarkAttribute), true))
            {
                RemarkAttribute remark = (RemarkAttribute)method.GetCustomAttribute(typeof(RemarkAttribute), true);
                Console.WriteLine($"我说方法的特性：{remark.Description}");
                remark.Show();
            }

            Console.WriteLine("******************************************************************");
            //访问方法参数的特性
            ParameterInfo parameter = method.GetParameters()[0];
            if (parameter.IsDefined(typeof(RemarkAttribute), true))
            {
                RemarkAttribute remark = (RemarkAttribute)parameter.GetCustomAttribute(typeof(RemarkAttribute), true);
                Console.WriteLine($"我是方法参数上的特性：{remark.Description}");
                remark.Show();
            }

            //特性上加一些验证的行为
            student.Validate();

        }
    }
}

Validate特性类，自定义的特性

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _002_Attribute
{
    /// <summary>
    /// 扩展方法：静态类，静态字段，this这单个特征组成的
    /// </summary>
    public static class ValidateExtension
    {
        public static bool Validate(this object oObject)
        {
            Type type = oObject.GetType();
            foreach (var prop in type.GetProperties())
            {
                if (prop.IsDefined(typeof(AbstractValidateBase), true))
                {
                    object[] attributeArray = prop.GetCustomAttributes(typeof(AbstractValidateBase), true);//得到所有的特性
                    foreach (AbstractValidateBase attribute in attributeArray)
                    {
                        if (!attribute.Validate(prop.GetValue(oObject)))
                        {
                            return false;
                        }
                    }
                }
            }
            return true;
        }
    }
    /// <summary>
    /// 抽象的基类
    /// </summary>
    public abstract class AbstractValidateBase : Attribute
    {
        public abstract bool Validate<T>(T tValue);
    }
    [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
    public class LengthAttribute : AbstractValidateBase
    {
        private int _Min = 0;
        private int _Max = 0;
        public LengthAttribute(int min, int max)
        {
            this._Min = min;
            this._Max = max;
        }
        public override bool Validate<T>(T tValue)
        {
            int length = tValue.ToString().Length;
            if (length > this._Min && length < this._Max)
            {
                return true;
            }
            return false;
        }
    }
    [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
    public class LongAttribute : AbstractValidateBase
    {
        private long _Min = 0;
        private long _Max = 0;
        public LongAttribute(long min, long max)
        {
            this._Min = min;
            this._Max = max;
        }
        public override bool Validate<T>(T tValue)
        {
            if (tValue != null && !string.IsNullOrWhiteSpace(tValue.ToString()))
            {
                if (long.TryParse(tValue.ToString(), out long result))//新语法，out这里不用提前声明变量了，直接写就行了
                {
                    if (result > this._Min && result < this._Max)
                    {
                        return true;
                    }
                }
            }
            return true;
        }
    }
    public class RemarkAttribute : Attribute
    {
        public RemarkAttribute()
        {

        }
        public string Description { get; set; }
        public void Show()
        {
            Console.WriteLine($"This is {nameof(RemarkAttribute)}");
        }
    }
}