c#中关于增强类功能的几种方式

本文主要讲解如何利用c#语言自身的特性来对一个类的功能进行丰富与增强，便于拓展现有项目的一些功能。

拓展方法

扩展方法被定义为静态方法，通过实例方法语法进行调用。方法的第一个参数指定该方法作用于哪个类型，并且该参数以 this 修饰符为前缀。仅当使用 using 指令将命名空间显式导入到源代码中之后，扩展方法才可使用。

namespace extensions
{

    public static class stringextension
    {
        public static datetime todatetime(this string source)
        {
            datetime.tryparse(source, out datetime result);
            return result;
        }
    }
}

注意：

• 如果扩展方法与该类型中定义的方法具有相同的签名，则扩展方法永远不会被调用。
• 在命名空间级别将扩展方法置于相应的作用范围内。例如，在一个名为 extensions 的命名空间中具有多个包含扩展方法的静态类，则在使用这些拓展方法时，必须引用其命名空间 using extensions

继承

继承 面向对象的一个特性，属于is a 关系，比如说student继承person,则说明student is a person。子类可以通过重写父类的方法或添加新的方法来实现对父类的拓展。

namespace inherit
{
    public class persion
    {
        public string name { get; set; }

        public int age { get; set; }

        public void eat()
        {
            console.writeline("吃饭");
        }

        public void sleep()
        {
            console.writeline("睡觉");
        }
    }

    public class student : persion
    {
        public void study()
        {
            console.writeline("学习");
        }

        public new void sleep()
        {
            console.writeline("做作业，复习功课");
            base.sleep();
        }
    }
}

继承的缺点：

• 父类的内部细节对子类是可见的
• 子类与父类的继承关系在编译阶段就确定下来了，无法在运行时动态改变从父类继承方法的行为
• 如果父类方法做了修改，所有的子类都必须做出相应的调整，子类与父类是一种高度耦合，违反了面向对象的思想。

组合

组合就是在设计类的时候把需要用到的类作为成员变量加入到当前类中。

组合的优缺点：

• 优点：
  • 隐藏了被引用对象的内部细节
  • 降低了两个对象之间的耦合
  • 可以在运行时动态修改被引用对象的实例
• 缺点：
  • 系统变更可能需要不停的定义新的类
  • 系统结构变复杂，不再局限于单个类

建议多使用组合，少用继承

装饰者模式

装饰者模式指在不改变原类定义及继承关系的情况跟下，动态的拓展一个类的功能，就是利用创建一个包装类（wrapper）来装饰（decorator）一个已有的类。

包含角色：

• 被装饰者：
  • component 抽象被装饰者，
  • concretecomponent 具体被装饰者，component的实现，在装饰者模式中装饰的就是这货。
• 装饰者：
  • decorator 装饰者 一般是一个抽象类并且作为component的子类，decorator必然会有一个成员变量用来存储component的实例
  • concreatedecorator 具体装饰者 decorator的实现

在装饰者模式中必然会有一个最基本，最核心，最原始的接口或抽象类充当component和decorator的抽象组件

实现要点：

• 定义一个类或接口，并且让装饰者及被装饰者的都继承或实现这个类或接口
• 装饰者中必须持有被装饰者的引用
• 装饰者中对需要增强的方法进行增强，不需要增强的方法调用原来的业务逻辑

namespace decorator
{

    /// <summary>
    ///  component 抽象者装饰者
    /// </summary>
    public interface istudent
    {
        void learn();
    }

    /// <summary>
    /// concretecomponent 具体被装饰者
    /// </summary>
    public class student : istudent
    {
        private string _name;
        public student(string name)
        {
            this._name = name;
        }
        public void learn()
        {
            system.console.writeline(this._name + "学习了以上内容");
        }
    }
    /// <summary>
    /// decorator 装饰者
    /// </summary>
    public abstract class teacher : istudent
    {
        private istudent _student;
        public teacher(istudent student)
        {
            this._student = student;
        }
        public virtual void learn()
        {
            this.rest();
            this._student.learn();
        }

        public virtual void rest()
        {
            console.writeline("课间休息");
        }
    }

    /// <summary>
    /// concretedecorator 具体装饰者
    /// </summary>
    public class mathteacher : teacher
    {
        private string _course;
        public mathteacher(istudent student, string course) : base(student)
        {
            this._course = course;
        }
        public override void learn()
        {
            system.console.writeline("学习新内容：" + this._course);
            base.learn();
        }
        public override void rest()
        {
            system.console.writeline("课间不休息，开始考试");
        }
    }

    /// <summary>
    /// concretedecorator 具体装饰者
    /// </summary>
    public class enlishteacher : teacher
    {
        private string _course;
        public enlishteacher(istudent student, string course) : base(student)
        {
            this._course = course;
        }

        public override void learn()
        {
            this.review();
            system.console.writeline("学习新内容：" + this._course);
            base.learn();
        }

        public void review()
        {
            system.console.writeline("复习英文单词");
        }
    }

    public class program
    {
        static void main(string[] args)
        {
            istudent student = new student("student");
            student = new mathteacher(student, "高数");
            student = new enlishteacher(student, "英语");
            student.learn();
        }
    }
}

装饰者模式优缺点：

• 优点：
  • 装饰者与被装饰者可以独立发展，不会互相耦合
  • 可以作为继承关系的替代方案，在运行时动态拓展类的功能
  • 通过使用不同的装饰者类或不同的装饰者排序，可以得到各种不同的结果
• 缺点：
  • 产生很多装饰者类
  • 多层装饰复杂

代理模式

代理模式就是给一个对象提供一个代理对象，并且由代理控制原对象的引用。

包含角色：

• 抽象角色：抽象角色是代理角色和被代理角色的所共同继承或实现的抽象类或接口
• 代理角色：代理角色是持有被代理角色引用的类，代理角色可以在执行被代理角色的操作时附加自己的操作
• 被代理角色：被代理角色是代理角色所代理的对象，是真实要操作的对象

静态代理

动态代理涉及到反射技术相对静态代理会复杂很多，掌握好动态代理对aop技术有很大帮助

namespace proxy
{
    /// <summary>
    /// 共同抽象角色
    /// </summary>
    public interface ibuyhouse
    {
        void buy();
    }

    /// <summary>
    /// 真实买房人，被代理角色
    /// </summary>
    public class customer : ibuyhouse
    {
        public void buy()
        {
            system.console.writeline("买房子");
        }
    }

    /// <summary>
    /// 中介-代理角色
    /// </summary>
    public class customerproxy : ibuyhouse
    {
        private ibuyhouse target;
        public customerproxy(ibuyhouse buyhouse)
        {
            this.target = buyhouse;
        }
        public void buy()
        {
            system.console.writeline("筛选符合条件的房源");
            this.target.buy();
        }
    }

    public class program
    {
        static void main(string[] args)
        {
            ibuyhouse buyhouse = new customerproxy(new customer());
            buyhouse.buy();
            system.console.readkey();
        }
    }
}

动态代理

namespace dynamicproxy
{
    using microsoft.extensions.dependencyinjection;
    using system;
    using system.collections.generic;
    using system.linq;
    using system.linq.expressions;
    using system.reflection;

    /// <summary>
    /// 方法拦截器接口
    /// </summary>
    public interface imethodinterceptor
    {
        /// <summary>
        /// 调用拦截器
        /// </summary>
        /// <param name="targetmethod">拦截的目标方法</param>
        /// <param name="args">拦截的目标方法参数列表</param>
        /// <returns>拦截的目标方法返回值</returns>
        object interceptor(methodinfo targetmethod, object[] args);
    }

    /// <summary>
    /// 代理类生成器
    /// </summary>
    public class proxyfactory : dispatchproxy
    {
        private imethodinterceptor _interceptor;

        /// <summary>
        /// 创建代理类实例
        /// </summary>
        /// <param name="targettype">要代理的接口</param>
        /// <param name="interceptor">拦截器</param>
        /// <returns></returns>
        public static object createinstance(type targettype, imethodinterceptor interceptor)
        {
            object proxy = getproxy(targettype);
            ((proxyfactory)proxy).getinterceptor(interceptor);
            return proxy;
        }

        /// <summary>
        /// 创建代理类实例
        /// </summary>
        /// <param name="targettype">要代理的接口</param>
        /// <param name="interceptortype">拦截器</param>
        /// <param name="parameters">拦截器构造函数参数值</param>
        /// <returns>代理实例</returns>
        public static object createinstance(type targettype, type interceptortype, params object[] parameters)
        {
            object proxy = getproxy(targettype);
            ((proxyfactory)proxy).getinterceptor(interceptortype, parameters);
            return proxy;
        }


        /// <summary>
        /// 创建代理类实例
        /// </summary>
        /// <typeparam name="ttarget">要代理的接口</typeparam>
        /// <typeparam name="tinterceptor">拦截器</typeparam>
        /// <param name="parameters">拦截器构造函数参数值</param>
        /// <returns></returns>
        public static ttarget createinstance<ttarget, tinterceptor>(params object[] parameters) where tinterceptor : imethodinterceptor
        {
            object proxy = getproxy(typeof(ttarget));
            ((proxyfactory)proxy).getinterceptor(typeof(tinterceptor), parameters);
            return (ttarget)proxy;
        }

        /// <summary>
        /// 获取代理类
        /// </summary>
        /// <param name="targettype"></param>
        /// <returns></returns>
        private static object getproxy(type targettype)
        {
            methodcallexpression callexp = expression.call(typeof(dispatchproxy), nameof(dispatchproxy.create), new[] { targettype, typeof(proxyfactory) });
            return expression.lambda<func<object>>(callexp).compile()();
        }

        /// <summary>
        /// 获取拦截器
        /// </summary>
        /// <param name="interceptortype"></param>
        /// <param name="parameters"></param>
        private void getinterceptor(type interceptortype, object[] parameters)
        {
            type[] ctorparams = parameters.select(x => x.gettype()).toarray();
            ienumerable<constantexpression> paramsexp = parameters.select(x => expression.constant(x));
            newexpression newexp = expression.new(interceptortype.getconstructor(ctorparams), paramsexp);
            this._interceptor = expression.lambda<func<imethodinterceptor>>(newexp).compile()();
        }

        /// <summary>
        /// 获取拦截器
        /// </summary>
        /// <param name="interceptor"></param>
        private void getinterceptor(imethodinterceptor interceptor)
        {
            this._interceptor = interceptor;
        }

        /// <summary>
        /// 执行代理方法
        /// </summary>
        /// <param name="targetmethod"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        protected override object invoke(methodinfo targetmethod, object[] args)
        {
            return this._interceptor.interceptor(targetmethod, args);
        }
    }

    /// <summary>
    /// 表演者
    /// </summary>
    public interface iperform
    {
        /// <summary>
        /// 唱歌
        /// </summary>
        void sing();

        /// <summary>
        /// 跳舞
        /// </summary>
        void dance();
    }

    /// <summary>
    /// 具体的表演者——刘德华 andy
    /// </summary>
    public class andyperformer : iperform
    {
        public void dance()
        {
            system.console.writeline("给大家表演一个舞蹈");
        }

        public void sing()
        {
            system.console.writeline("给大家唱首歌");
        }
    }

    /// <summary>
    /// 经纪人——负责演员的所有活动
    /// </summary>
    public class performagent : imethodinterceptor
    {
        public iperform _perform;
        public performagent(iperform perform)
        {
            this._perform = perform;
        }
        public object interceptor(methodinfo targetmethod, object[] args)
        {
            system.console.writeline("各位大佬，要我们家艺人演出清闲联系我");
            object result = targetmethod.invoke(this._perform, args);
            system.console.writeline("各位大佬，表演结束该付钱了");
            return result;
        }
    }

    public class program
    {
        static void main(string[] args)
        {
            iperform perform;

            //perform = proxyfactory.createinstance<iperform, performagent>(new andyperformer());
            //perform.sing();
            //perform.dance();

            servicecollection servicedescriptors = new servicecollection();
            servicedescriptors.addsingleton<iperform>(proxyfactory.createinstance<iperform, performagent>(new andyperformer()));
            iserviceprovider serviceprovider = servicedescriptors.buildserviceprovider();
            perform = serviceprovider.getservice<iperform>();
            perform.sing();
            perform.dance();

            system.console.readkey();
        }
    }

}

总结

• 使用拓展方法只能拓展新增方法，不能增强已有的功能
• 使用继承类或接口，类只能单继承，并且在父类改变后，所有的子类都要跟着变动
• 使用代理模式与继承一样代理对象和真实对象之间的的关系在编译时就确定了
• 使用装饰者模式能够在运行时动态地增强类的功能

参考引用

利用.net core类库system.reflection.dispatchproxy实现简易aop