歡迎光臨
每天分享高質量文章

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 { getset; }

        public int Age { getset; }

        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
{

    /// 
    ///  Component 抽象者裝飾者
    /// 


    public interface IStudent
    {
        void Learn();
    }

    /// 
    /// ConcreteComponent 具體被裝飾者
    /// 
    public class Student : IStudent
    {
        private string _name;
        public Student(string name)
        
{
            this._name = name;
        }
        public void Learn()
        
{
            System.Console.WriteLine(this._name + “學習了以上內容”);
        }
    }
    /// 
    /// Decorator 裝飾者
    /// 
    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(“課間休息”);
        }
    }

    /// 
    /// ConcreteDecorator 具體裝飾者
    /// 
    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(“課間不休息,開始考試”);
        }
    }

    /// 
    /// ConcreteDecorator 具體裝飾者
    /// 
    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
{
    /// 
    /// 共同抽象角色
    /// 


    public interface IBuyHouse
    {
        void Buy();
    }

    /// 
    /// 真實買房人,被代理角色
    /// 
    public class Customer : IBuyHouse
    {
        public void Buy()
        
{
            System.Console.WriteLine(“買房子”);
        }
    }

    /// 
    /// 中介-代理角色
    /// 
    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;

    /// 
    /// 方法攔截器接口
    /// 


    public interface IMethodInterceptor
    {
        /// 
        /// 呼叫攔截器
        /// 
        /// 攔截的標的方法
        /// 攔截的標的方法引數串列
        /// 攔截的標的方法傳回值
        object Interceptor(MethodInfo targetMethod, object[] args);
    }

    /// 
    /// 代理類生成器
    /// 
    public class ProxyFactory : DispatchProxy
    {
        private IMethodInterceptor _interceptor;

        /// 
        /// 創建代理類實體
        /// 
        /// 要代理的接口
        /// 攔截器
        /// 
        public static object CreateInstance(Type targetType, IMethodInterceptor interceptor)
        
{
            object proxy = GetProxy(targetType);
            ((ProxyFactory)proxy).GetInterceptor(interceptor);
            return proxy;
        }

        /// 
        /// 創建代理類實體
        /// 
        /// 要代理的接口
        /// 攔截器
        /// 攔截器建構式引數值
        /// 代理實體
        public static object CreateInstance(Type targetType, Type interceptorType, params object[] parameters)
        
{
            object proxy = GetProxy(targetType);
            ((ProxyFactory)proxy).GetInterceptor(interceptorType, parameters);
            return proxy;
        }


        /// 
        /// 創建代理類實體
        /// 
        /// 要代理的接口
        /// 攔截器
        /// 攔截器建構式引數值
        /// 
        public static TTarget CreateInstance(params object[] parameters) where TInterceptor : IMethodInterceptor
        {
            object proxy = GetProxy(typeof(TTarget));
            ((ProxyFactory)proxy).GetInterceptor(typeof(TInterceptor), parameters);
            return (TTarget)proxy;
        }

        /// 
        /// 獲取代理類
        /// 
        /// 
        /// 
        private static object GetProxy(Type targetType)
        
{
            MethodCallExpression callexp = Expression.Call(typeof(DispatchProxy), nameof(DispatchProxy.Create), new[] { targetType, typeof(ProxyFactory) });
            return Expression.Lambdaobject>>(callexp).Compile()();
        }

        /// 
        /// 獲取攔截器
        /// 
        /// 
        /// 
        private void GetInterceptor(Type interceptorType, object[] parameters)
        
{
            Type[] ctorParams = parameters.Select(x => x.GetType()).ToArray();
            IEnumerable paramsExp = parameters.Select(x => Expression.Constant(x));
            NewExpression newExp = Expression.New(interceptorType.GetConstructor(ctorParams), paramsExp);
            this._interceptor = Expression.Lambda>(newExp).Compile()();
        }

        /// 
        /// 獲取攔截器
        /// 
        /// 
        private void GetInterceptor(IMethodInterceptor interceptor)
        
{
            this._interceptor = interceptor;
        }

        /// 
        /// 執行代理方法
        /// 
        /// 
        /// 
        /// 
        protected override object Invoke(MethodInfo targetMethod, object[] args)
        
{
            return this._interceptor.Interceptor(targetMethod, args);
        }
    }

    /// 
    /// 表演者
    /// 
    public interface IPerform
    {
        /// 
        /// 唱歌
        /// 
        void Sing();

        /// 
        /// 跳舞
        /// 
        void Dance();
    }

    /// 
    /// 具體的表演者——劉德華 Andy
    /// 
    public class AndyPerformer : IPerform
    {
        public void Dance()
        
{
            System.Console.WriteLine(“給大家表演一個舞蹈”);
        }

        public void Sing()
        
{
            System.Console.WriteLine(“給大家唱首歌”);
        }
    }

    /// 
    /// 經紀人——負責演員的所有活動
    /// 
    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(new AndyPerformer());
            //perform.Sing();
            //perform.Dance();

            ServiceCollection serviceDescriptors = new ServiceCollection();
            serviceDescriptors.AddSingleton(ProxyFactory.CreateInstance(new AndyPerformer()));
            IServiceProvider serviceProvider = serviceDescriptors.BuildServiceProvider();
            perform = serviceProvider.GetService();
            perform.Sing();
            perform.Dance();

            System.Console.ReadKey();
        }
    }

}

總結

  • 使用拓展方法只能拓展新增方法,不能增強已有的功能

  • 使用繼承類或接口,類只能單繼承,並且在父類改變後,所有的子類都要跟著變動

  • 使用代理樣式與繼承一樣代理物件和真實物件之間的的關係在編譯時就確定了

  • 使用裝飾者樣式能夠在運行時動態地增強類的功能

參考取用

利用.NET Core類庫System.Reflection.DispatchProxy實現簡易Aop

https://www.cnblogs.com/ElderJames/p/implement-simple-Aop-using-a-dotnet-core-library-System-Reflection-DispatchProxy.html

赞(0)

分享創造快樂