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