如果你在实际开发中没感觉到OOP的一些缺陷，就不要往下看了！
如果你不了解AOP，或类似AOP的思路，请先去了解一下AOP相关的认识。
如果你是概念党，或是经验党，或是从众党，也请不要看了！
我实现的只是一个小功能，是不是AOP我并不清楚，也不主要，标题那样写只是让大家一看就明白本文讲的大概是什么，况且我也想不出写个什么标题。
因为我看了别人谈论的AOP，扯到好多东西，代理啦、emit啦等等天花乱坠的，不过一个也没看懂（I hate complex）！
但有一点对我很有用，就是几种通知类型：
1，目标方法调用前（before）
2，目标方法调用后（after）---目标方法异常也执行
3，目标方法返回后（after return）---目标方法异常不执行
3，目标方法调用前后（around）
4，目标方法抛出异常时（throw）
我感觉稍微整理一下更好理解，所以下方的实现是基于这6种类型的：
1，目标方法调用前（Before）
2，目标方法调用后（After）--目标方法异常是不执行的！
3，目标方法调用后（AfterEnsure） --目标方法异常也执行。
4，目标方法调用前后（Around）--目标方法异常，After是不执行的
5，目标方法调用前后（AroundEnsure）--目标方法异常，After也执行
6，目标方法抛出异常时（Throw）
考虑到多种通知处理，就需要一个统一接口(泛指接口)， 而这里抽象类比.net接口更合适：（这个组件只有两个类，这是其中之一）
public abstract class AspectAdvice
{
public virtual void Before(object target, MethodInfo mi, params object[] args) { }
public virtual void After(object target, MethodInfo mi, params object[] args) { }
public virtual void Throw(object target, MethodInfo mi, params object[] args) { }
}
三个方法就够了，这三个方法与目标方法不同的调用逻辑可以满足上面6种通知，下面再分析。
为了好描述，我也以日志记录为例，下面分别是目标类，和日志类（可以叫它切面吗？呵呵）
public class MyClass
{
//无返回值
public void Act()
{
Console.WriteLine("MyClass.Act()");
}
//有返回值
public int Fun(string str)
{
return str.Length;
}
;
//用到对象成员m_num，可能发生异常
public int Divide(int n)
{
return m_num / n;
}
//静态方法
public static void SFun(string str)
{
Console.WriteLine(str);
}
}
通知处理类都要实现AspectAdvice， 如日志类：
public class Log : AspectAdvice
{
public override void Before(object target, MethodInfo mi, params object[] args)
{
Console.WriteLine("===========Log Before===========");
}
public override void After(object target, MethodInfo mi, params object[] args)
{
Console.WriteLine("===========Log After===========");
}
public override void Throw(object target, MethodInfo mi, params object[] args)
{
Console.WriteLine("===========Log Exception===========");
}
private Log() { }
static Log m_instance;
public static Log Instance
{
get
{
if (m_instance == null)
m_instance = new Log();
return m_instance;
}
}
}
请不要纠结用单件实例化，在这里只是单件适合一点，其实一个Log对象是可以做为容器上下文的，比如在用Around通知时，可以在Before方法里对Log对象的一个成员(上面没给出)赋值，After方法可以使用。
如何调用呢？直接调用一定是这样的：
现在就要去实现组件的第二个也是最后一个类了，AspectInvoker类，AspectInvoker类很大，1700多行， 但也很简单，只有6个方法，每个方法有34个重载，就不贴全码了，最后给两个类的下载。
先来个简单的调用一睹为快：
是不是已经有点意思了呢？AspectInvoker.Beore有两个参数，第一个是AspectAdvice的子类，这里是个Log类的对象，第二个是一个Action委托，这里是myClass.Act方法。AspectInvoker.Beore方法是超级简单的：
public static void Before(AspectAdvice advice, Action act)
{
advice.Before(act.Target, act.Method);
act();
}
怎么样？最复杂的思路已经完成了！执行上有效率问题吗？
再来个调用MyClass类的Fun方法的，这个方法有个参数，有个返回值：
这个是Around的调用，第一个参数不变，第二个参数不变，因为myClass.Fun有参数，所以第三个是myClass.Fun的第一个参数（如果有多个，以次往后写就是了），最后一个输出参数是myClas.Fun的返回值。AspectInvoker.Around的实现只是比猫画虎罢了，前面说了，最复杂的思路已经完成！
public static void Around<T, TResult>(AspectAdvice advice, Func<T, TResult> fun, T t, out TResult result)
{
advice.Before(fun.Target, fun.Method, t);
result = fun(t);
advice.After(fun.Target, fun.Method, t);
}
再来个抛异常的，这个可以用AspectInvoker.AfterEnsure或AspectInvoker.Throw来测试，下图是AspectInvoker.AfterEnsure的结果：
异常发生了，Log.After也执行了，这就是AspectInvoker.AfterEnsure，确保了After的执行。如果用AspectInvoker.Throw，只有异常时才执行Log.Throw，调用方法的实现还是画虎罢了：
public static void AfterEnsure<T, TResult>(AspectAdvice advice, Func<T, TResult> fun, T t, out TResult result)
{
try
{
result = fun(t);
}
finally
{
advice.After(fun.Target, fun.Method, t);
}
}
public static void Throw<T, TResult>(AspectAdvice advice, Func<T, TResult> fun, T t, out TResult result)
{
try
{
result = fun(t);
}
catch (Exception exp)
{
advice.Throw(fun.Target, fun.Method, t);
throw exp;
}
}
最后还有MyClass.SFun的静态方法，这里就不多说了，说多了都是Repeat!
总结：
1，AspectInvoker类的6个调用方法都可以调用参数在17个以下的目标方法，因为泛型Action和泛型Func最多都是16个，所以我也写到了16个(这个完全不是限制)。
2，AspectInvoker类不能调用有out参数和ref参数的目标方法。
3，这个组件是简单的，是高效的，和现有的AOP框架肯定是有出入的！请不要和它们对比，这个组件的目的不在于此！
4，MyClass类不用包装，不用继承什么，AspectInvoker关注的只是方法，不管是静态方法还是实例方法，不管是你的方法还是我的方法....
5，你真的知道怎么用了吧？大多数人是没问题的，我担心的只是不爱思考的同学：
1），Log的实现现在是数据库，随时换成记录到文本没问题的
2），AspectAdvice的方法都有三个参数，第一个是目标方法的对象target（如果是静态方法，target是null），第二个是目标方法的MethodInfo，第三个是目标方法的参数数组
比如target类型就可以做些事情等等。
3）
6，下载
完...
2013-09-27修改：
把调用也写到AspectAdvice，调用方法有所改善，返回值不用out参数，而是直接返回，上述例子中新的调用如下：
static void Main(string[] args)
{
MyClass myClass = new MyClass();
Log.Instance.BeforeAction(myClass.Act);
int len = Log.Instance.AroundFunc(myClass.Fun, "a string param");
Console.WriteLine(len);
);
Console.WriteLine(result);
}
注：为什么要分开Action和Func的调用方法名称呢，因为Action<T,T>和Func<T,T,TResult>在C#里无法区分，方法签名不包括返回值，这点使人不是很爽！