C#中增強類功能的幾種方式詳解

更新時間：2018年12月30日 09:54:59 作者：Alvin.Lee

這篇文章主要給大家介紹了關于C#中增強類功能的幾種方式的相關資料，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面來一起學習學習吧

前言

本文主要講解如何利用C#語言自身的特性來對一個類的功能進行豐富與增強，便于拓展現(xiàn)有項目的一些功能。

拓展方法

擴展方法被定義為靜態(tài)方法，通過實例方法語法進行調用。方法的第一個參數(shù)指定該方法作用于哪個類型，并且該參數(shù)以 this 修飾符為前綴。僅當使用 using 指令將命名空間顯式導入到源代碼中之后，擴展方法才可使用。

namespace Extensions
{

 public static class StringExtension
 {
 public static DateTime ToDateTime(this string source)
 {
  DateTime.TryParse(source, out DateTime result);
  return result;
 }
 }
}

注意：

如果擴展方法與該類型中定義的方法具有相同的簽名，則擴展方法永遠不會被調用。
在命名空間級別將擴展方法置于相應的作用范圍內(nèi)。例如，在一個名為 Extensions 的命名空間中具有多個包含擴展方法的靜態(tài)類，則在使用這些拓展方法時，必須引用其命名空間 using Extensions

繼承

繼承面向對象的一個特性，屬于Is a 關系，比如說Student繼承Person,則說明Student is a Person。子類可以通過重寫父類的方法或添加新的方法來實現(xiàn)對父類的拓展。

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("做作業(yè)，復習功課");
  base.Sleep();
 }
 }
}

繼承的缺點：

父類的內(nèi)部細節(jié)對子類是可見的
子類與父類的繼承關系在編譯階段就確定下來了，無法在運行時動態(tài)改變從父類繼承方法的行為
如果父類方法做了修改，所有的子類都必須做出相應的調整，子類與父類是一種高度耦合，違反了面向對象的思想。

組合

組合就是在設計類的時候把需要用到的類作為成員變量加入到當前類中。

組合的優(yōu)缺點：

優(yōu)點：

隱藏了被引用對象的內(nèi)部細節(jié)
降低了兩個對象之間的耦合
可以在運行時動態(tài)修改被引用對象的實例

缺點：

系統(tǒng)變更可能需要不停的定義新的類
系統(tǒng)結構變復雜，不再局限于單個類

建議多使用組合，少用繼承

裝飾者模式

裝飾者模式指在不改變原類定義及繼承關系的情況跟下，動態(tài)的拓展一個類的功能，就是利用創(chuàng)建一個包裝類（wrapper）來裝飾（decorator）一個已有的類。

包含角色：

被裝飾者：

Component 抽象被裝飾者，
ConcreteComponent 具體被裝飾者，Component的實現(xiàn)，在裝飾者模式中裝飾的就是這貨。

裝飾者：

Decorator 裝飾者一般是一個抽象類并且作為Component的子類，Decorator必然會有一個成員變量用來存儲Component的實例
ConcreateDecorator 具體裝飾者 Decorator的實現(xiàn)

在裝飾者模式中必然會有一個最基本，最核心，最原始的接口或抽象類充當component和decorator的抽象組件

實現(xiàn)要點：

定義一個類或接口，并且讓裝飾者及被裝飾者的都繼承或實現(xiàn)這個類或接口
裝飾者中必須持有被裝飾者的引用
裝飾者中對需要增強的方法進行增強，不需要增強的方法調用原來的業(yè)務邏輯

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 + "學習了以上內(nèi)容");
  }
 }
 /// <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("學習新內(nèi)容：" + 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("學習新內(nèi)容：" + 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, "高數(shù)");
   student = new EnlishTeacher(student, "英語");
   student.Learn();
  }
 }
}

裝飾者模式優(yōu)缺點：

優(yōu)點：

裝飾者與被裝飾者可以獨立發(fā)展，不會互相耦合
可以作為繼承關系的替代方案，在運行時動態(tài)拓展類的功能
通過使用不同的裝飾者類或不同的裝飾者排序，可以得到各種不同的結果

缺點：

產(chǎn)生很多裝飾者類
多層裝飾復雜

代理模式

代理模式就是給一個對象提供一個代理對象，并且由代理控制原對象的引用。

包含角色：

抽象角色：抽象角色是代理角色和被代理角色的所共同繼承或實現(xiàn)的抽象類或接口
代理角色：代理角色是持有被代理角色引用的類，代理角色可以在執(zhí)行被代理角色的操作時附加自己的操作
被代理角色：被代理角色是代理角色所代理的對象，是真實要操作的對象

靜態(tài)代理

動態(tài)代理涉及到反射技術相對靜態(tài)代理會復雜很多，掌握好動態(tài)代理對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();
  }
 }
}

動態(tài)代理

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">攔截的目標方法參數(shù)列表</param>
  /// <returns>攔截的目標方法返回值</returns>
  object Interceptor(MethodInfo targetMethod, object[] args);
 }

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

  /// <summary>
  /// 創(chuàng)建代理類實例
  /// </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>
  /// 創(chuàng)建代理類實例
  /// </summary>
  /// <param name="targetType">要代理的接口</param>
  /// <param name="interceptorType">攔截器</param>
  /// <param name="parameters">攔截器構造函數(shù)參數(shù)值</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>
  /// 創(chuàng)建代理類實例
  /// </summary>
  /// <typeparam name="TTarget">要代理的接口</typeparam>
  /// <typeparam name="TInterceptor">攔截器</typeparam>
  /// <param name="parameters">攔截器構造函數(shù)參數(shù)值</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>
  /// 執(zhí)行代理方法
  /// </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>
 /// 經(jīng)紀人——負責演員的所有活動
 /// </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("各位大佬，要我們家藝人演出清閑聯(lián)系我");
   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();
  }
 }

}

總結