利用Lambda表达式、扩展方法以及泛型来实现一个另类的AOP

假设我们有如下的代码

public class SecurityServiceProxy
　　{
　　　　public string Encrypt(string input)
　　　　{
　　　　　　try
　　　　　　{
　　　　　　　　return new SecurityServiceClient().Encrypt(input);
　　　　　　}
　　　　　　catch(Exception ex)
　　　　　　{
　　　　　　　　//Log Exception
　　　　　　　　throw;
　　　　　　}
　　　　}

　　　　public string Decrypt(string input)
　　　　{
　　　　　　try
　　　　　　{
　　　　　　　　return new SecurityServiceClient().Decrypt(input);
　　　　　　}
　　　　　　catch(Exception ex)
　　　　　　{
　　　　　　　　//Log Exception
　　　　　　　　throw;
　　　　　　}
　　　　}
　　}

这个代码中有两段重复（异常处理块重复以及在异常时记Log的逻辑重复），这个重复从AOP的角度来看的话应该是属于横切关注点，所以如果能以AOP的方式解决那应该是最好的方案了，以下实现了一种特殊形式的AOP，代码如下：

public class SecurityServiceProxy
　　{
　　　　public string Encrypt(string input)
　　　　{
　　　　    return new SecurityServiceClient().ExecAndLogExcetion(client => client .Encrypt(input));
　　　　}

　　　　public string Decrypt(string input)
　　　　{
　　　　    return new SecurityServiceClient().ExecAndLogExcetion(client => client .Decrypt(input));
　　　　}
　　}

现在的代码已经简捷多了，这主要是因为利用到了如下的扩展方法：

public static class ObjectExtensions
{
public static void LockExec<T>(this T obj, Action<T> action) where T : class
{
lock (obj)
{
action(obj);
}
}

public static void ExecAndLogExcetion<T>(this T obj, Action<T> action)
{
try
{
action(obj);
}
catch (Exception)
{
//log excetion
throw;
}
}

public static void ExecAndLogExcetion<T1, T2>(this T1 obj, T2 obj1, Action<T1, T2> action)
{
try
{
action(obj, obj1);
}
catch (Exception)
{
//log excetion
throw;
}
}

public static TResult ExecAndLogExcetion<T, TResult>(this T obj, Func<T, TResult> func)
{
try
{
return func(obj);
}
catch (Exception)
{
//log excetion
throw;
}
}

public static TResult ExecAndLogExcetion<T1, T2, TResult>(this T1 obj, T2 obj1, Func<T1, T2, TResult> func)
{
try
{
return func(obj, obj1);
}
catch (Exception)
{
//log excetion
throw;
}
}
}