C# アドバンスト シリーズ - AOP?あおっ！
- 黄舟オリジナル
- 2017-02-07 15:40:111490ブラウズ
前書き: この記事は AOP について説明します。AOP について言えば、実際、ブロガーはこの概念を理解してから数か月しか経っていませんが、以前に書いたコードの原則の多くが基づいていることに気づきました。 MVC のフィルターなどの AOP では、その中の例外キャプチャは FilterAttribute と IExceptionFilter を通じて処理できるはずですが、以前はそのような概念はありませんでした。
1. AOP の概念
古いルール、最初に公式の説明を見てみましょう: AOP (アスペクト指向プログラミング)、プリコンパイルとランタイム動的エージェントを通じて実装できます。ソースコードを変更することなく、プログラムに機能を均一に追加します。これは、従来の OOP プログラミングを補完する新しい方法論です。 OOP は、必要な関数をさまざまな比較的独立した、適切にカプセル化されたクラスに分割し、それらの関係を定義するために継承とポリモーフィズムに依存して、それらが独自の動作を行えるようにすることに焦点を当てており、AOP は一般的な必要な関数を関連クラスの分離から変換できることを望んでいます。変更が発生すると、多くのクラスが動作を共有できるようになります。変更する必要があるのは動作のみです。 AOP はアスペクトを使用して横断的な関心事をモジュール化し、OOP はクラスを使用して状態と動作をモジュール化します。 OOP の世界では、プログラムはクラスとインターフェイスを通じて編成されており、これらを使用してプログラムのコア ビジネス ロジックを実装するのが非常に適切です。ただし、ロギング、権限の検証、例外のインターセプトなど、横断的な懸念事項 (アプリケーションの複数のモジュールにまたがる機能要件) を実装することは非常に困難です。
ブロガーの理解: AOP は共通関数を抽出するもので、将来的に共通関数の要件が変更された場合、共通モジュールのコードを変更するだけでよく、複数の呼び出し場所を変更する必要はありません。いわゆるアスペクト指向とは、ビジネス ロジックではなく、一般的な機能のみに焦点を当てることを意味します。通常、実装はインターセプトによって行われます。たとえば、私たちの Web プロジェクトには基本的に、各ページに入る前に、現在ログインしているユーザーにインターフェイスを表示する権限があるかどうかを確認する機能があります。この段落を初期化メソッドで記述することは不可能です。このとき、AOP のメカニズムは一連の特性を事前に定義することで、メソッドをインターセプトする機能を備え、必要な処理を事前に実行できるようにします。メソッドの実行後、それを使用するときは、対応するメソッドまたはクラス定義に特定の機能を追加するだけで済みます。
2. AOP を使用する利点
その利点は主に次の点に反映されているとブロガーは考えています。コードを維持します。
2. ソフトウェアを設計する際に、共通の機能 (側面) を抽出すると、ソフトウェア設計のモジュール化が促進され、ソフトウェア アーキテクチャの複雑さが軽減されます。つまり、汎用機能は別モジュールであり、汎用機能の設計コードはプロジェクトの本業では見ることができません。
3. AOP の簡単なアプリケーション
AOP の動作原理を説明するために、ブロガーは、AOP が静的インターセプトを通じてどのように動作するかを理解するための簡単な例から始める予定です。
1. 静的傍受
public class Order
{
public int Id { set; get; }
public string Name { set; get; }
public int Count { set; get; }
public double Price { set; get; }
public string Desc { set; get; }
}
public interface IOrderProcessor
{
void Submit(Order order);
}
public class OrderProcessor : IOrderProcessor
{
public void Submit(Order order)
{
Console.WriteLine("提交订单");
}
}
public class OrderProcessorDecorator : IOrderProcessor
{
public IOrderProcessor OrderProcessor { get; set; }
public OrderProcessorDecorator(IOrderProcessor orderprocessor)
{
OrderProcessor = orderprocessor;
}
public void Submit(Order order)
{
PreProceed(order);
OrderProcessor.Submit(order);
PostProceed(order);
}
public void PreProceed(Order order)
{
Console.WriteLine("提交订单前，进行订单数据校验....");
if (order.Price 0)
{
Console.WriteLine("订单总价有误，请重新核对订单。");
}
}
public void PostProceed(Order order)
{
Console.WriteLine("提交带单后，进行订单日志记录......");
Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + "提交订单，订单名称：" + order.Name + "，订单价格：" + order.Price);
}
}呼び出しコード:
static void Main(string[] args)
{
Order order = new Order() { Id = 1, Name = "lee", Count = 10, Price = 100.00, Desc = "订单测试" };
IOrderProcessor orderprocessor = new OrderProcessorDecorator(new OrderProcessor());
orderprocessor.Submit(order);
Console.ReadLine();
}取得結果:
上面我们模拟订单提交的例子，在提交一个订单前，我们需要做很多的准备工作，比如数据有效性校验等；订单提交完成之后，我们还需要做日志记录等。上面的代码很简单，没有任何复杂的逻辑，从上面的代码可以看出，我们通过静态植入的方式手动在执行方法前和执行方法后让它做一些我们需要的功能。AOP的实现原理应该也是如此，只不过它帮助我们做了方法拦截，帮我们省去了大量重复代码，我们要做的仅仅是写好拦截前和拦截后需要处理的逻辑。
2、动态代理
了解了静态拦截的例子，你是否对AOP有一个初步的认识了呢。下面我们就来到底AOP该如何使用。按照园子里面很多牛人的说法，AOP的实现方式大致可以分为两类：动态代理和IL 编织两种方式。博主也不打算照本宣科，分别拿Demo来说话吧。下面就以两种方式各选一个代表框架来说明。
动态代理方式，博主就以微软企业库(MS Enterprise Library)里面的PIAB(Policy Injection Application Block)框架来作说明。
首先需要下载以下几个dll，然后添加它们的引用。
然后定义对应的Handler
public class User
{
public string Name { set; get; }
public string PassWord { set; get; }
}
#region 1、定义特性方便使用
public class LogHandlerAttribute : HandlerAttribute
{
public string LogInfo { set; get; }
public int Order { get; set; }
public override ICallHandler CreateHandler(IUnityContainer container)
{
return new LogHandler() { Order = this.Order, LogInfo = this.LogInfo };
}
}
#endregion
#region 2、注册对需要的Handler拦截请求
public class LogHandler : ICallHandler
{
public int Order { get; set; }
public string LogInfo { set; get; }
//这个方法就是拦截的方法，可以规定在执行方法之前和之后的拦截
public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
{
Console.WriteLine("LogInfo内容" + LogInfo);
//0.解析参数
var arrInputs = input.Inputs;
if (arrInputs.Count > 0)
{
var oUserTest1 = arrInputs[0] as User;
}
//1.执行方法之前的拦截
Console.WriteLine("方法执行前拦截到了");
//2.执行方法
var messagereturn = getNext()(input, getNext);
//3.执行方法之后的拦截
Console.WriteLine("方法执行后拦截到了");
return messagereturn;
}
}
#endregion
#region 3、用户定义接口和实现
public interface IUserOperation
{
void Test(User oUser);
void Test2(User oUser, User oUser2);
}
//这里必须要继承这个类MarshalByRefObject，否则报错
public class UserOperation : MarshalByRefObject, IUserOperation
{
private static UserOperation oUserOpertion = null;
public UserOperation()
{
//oUserOpertion = PolicyInjection.Create();
}
//定义单例模式将PolicyInjection.Create()产生的这个对象传出去，这样就避免了在调用处写这些东西
public static UserOperation GetInstance()
{
if (oUserOpertion == null)
oUserOpertion = PolicyInjection.Create();
return oUserOpertion;
}
//调用属性也会拦截
public string Name { set; get; }
//[LogHandler]，在方法上面加这个特性，只对此方法拦截
[LogHandler(LogInfo = "Test的日志为aaaaa")]
public void Test(User oUser)
{
Console.WriteLine("Test方法执行了");
}
[LogHandler(LogInfo = "Test2的日志为bbbbb")]
public void Test2(User oUser, User oUser2)
{
Console.WriteLine("Test2方法执行了");
}
}
#endregion最后我们来看调用的代码：
static void Main(string[] args)
{
try
{
var oUserTest1 = new User() { Name = "test2222", PassWord = "yxj" };
var oUserTest2 = new User() { Name = "test3333", PassWord = "yxj" };
var oUser = UserOperation.GetInstance();
oUser.Test(oUserTest1);
oUser.Test2(oUserTest1,oUserTest2);
}
catch (Exception ex)
{
//throw;
}
}得到结果如下：
我们来看执行Test()方法和Test2()方法时候的顺序。
由于Test()和Test2()方法上面加了LogHander特性，这个特性里面定义了AOP的Handler，在执行Test和Test2方法之前和之后都会进入Invoke()方法里面。其实这就是AOP的意义所在，将切面的通用功能在统一的地方处理，在主要逻辑里面直接用过特性使用即可。
3、IL编织
静态织入的方式博主打算使用PostSharp来说明，一来这个使用起来简单，二来项目中用过这种方式。
Postsharp从2.0版本就开始收费了。为了说明AOP的功能，博主下载了一个免费版本的安装包，使用PostSharp与其它框架不太一样的是一定要下载安装包安装，只引用类库是不行的，因为上文说过，AOP框架需要为编译器或运行时添加扩展。使用步骤如下：
（1）下载Postsharp安装包，安装。
（2）在需要使用AOP的项目中添加PostSharp.dll 这个dll的引用。
（3）定义拦截的方法：
[Serializable]
public class TestAop : PostSharp.Aspects.OnMethodBoundaryAspect
{
//发生异常时进入此方法
public override void OnException(MethodExecutionArgs args)
{
base.OnException(args);
}
//执行方法前执行此方法
public override void OnEntry(MethodExecutionArgs args)
{
base.OnEntry(args);
}
//执行方法后执行此方法
public override void OnExit(MethodExecutionArgs args)
{
base.OnExit(args);
}
}注意这里的TestAop这个类必须要是可序列化的，所以要加上[Serializable]特性
（4）在需要拦截功能的地方使用。
在类上面加特性拦截，此类下面的所有的方法都会具有拦截功能。
[TestAop]public class Impc_TM_PLANT : Ifc_TM_PLANT
{
///
/// 获取或设置服务接口。
///
private Ic_TM_PLANTService service { get; set; }
public IList Find()
{
DTO_TM_PLANT otest = null;
otest.NAME_C = "test";
//异常，会进入OnException方法
return service.FindAll();
}
}方法上面加特性拦截，只会拦截此方法。
[TestAop]
public IList Find()
{
DTO_TM_PLANT otest = null;
otest.NAME_C = "test";
return service.FindAll();
}有没有感觉很简单，很强大，其实这一简单应用，解决我们常见的日志、异常、权限验证等功能简直太小菜一碟了。当然Postsharp可能还有许多更加高级的功能，有兴趣可以深究下。
4、MVC里面的Filter
public class AOPFilterAttribute : ActionFilterAttribute, IExceptionFilter
{
public void OnException(ExceptionContext filterContext)
{
throw new System.NotImplementedException();
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
base.OnActionExecuting(filterContext);
}
public override void OnActionExecuted(ActionExecutedContext filterContext)
{
base.OnActionExecuted(filterContext);
}
}在controller里面使用该特性：
[AOPFilter]
public JsonResult GetEditModel(string strType)
{
var lstRes = new List>();
var lstResPage = new List();
//.........todo
return Json(new { lstDataAttr = lstRes, PageAttr = lstResPage, lstJsConnections = lstJsPlumbLines }, JsonRequestBehavior.AllowGet);
}调试可知，在执行GetEditModel(string strType)方法之前，会先执行OnActionExecuting()方法，GetEditModel(string strType)之后，又会执行OnActionExecuted()方法。这在我们MVC里面权限验证、错误页导向、日志记录等常用功能都可以方便解决。
上記は C# 上級シリーズ - AOP?あおっ！関連コンテンツの詳細については、PHP 中国語 Web サイト (www.php.cn) に注目してください。