AspectInjector
一个开源的轻量级AOP框架，满足大多数场景。但由于该框架注入异步方法不是很方便，故记录下解决方案。
封装通用基类
public abstract class BaseUniversalWrapperAspect
{
private delegate object Method(object[] args);
private delegate object Wrapper(Func<object[], object> target, object[] args);
private delegate object Handler(Func<object[], object> next, object[] args, AspectEventArgs eventArgs);
private static readonly ConcurrentDictionary<(MethodBase, Type), Lazy<Handler>> _delegateCache = new ConcurrentDictionary<(MethodBase, Type), Lazy<Handler>>();
private static readonly MethodInfo _asyncGenericHandler =
typeof(BaseUniversalWrapperAttribute).GetMethod(nameof(BaseUniversalWrapperAttribute.WrapAsync), BindingFlags.NonPublic | BindingFlags.Instance);
private static readonly MethodInfo _syncGenericHandler =
typeof(BaseUniversalWrapperAttribute).GetMethod(nameof(BaseUniversalWrapperAttribute.WrapSync), BindingFlags.NonPublic | BindingFlags.Instance);
private static readonly Type _voidTaskResult = Type.GetType("System.Threading.Tasks.VoidTaskResult");
protected object BaseHandle(
object instance,
Type type,
MethodBase method,
Func<object[], object> target,
string name,
object[] args,
Type returnType,
Attribute[] triggers)
{
var eventArgs = new AspectEventArgs
{
Instance = instance,
Type = type,
Method = method,
Name = name,
Args = args,
ReturnType = returnType,
Triggers = triggers
};
var wrappers = triggers.OfType<BaseUniversalWrapperAttribute>().ToArray();
var handler = GetMethodHandler(method, returnType, wrappers);
return handler(target, args, eventArgs);
}
private Handler CreateMethodHandler(Type returnType, IReadOnlyList<BaseUniversalWrapperAttribute> wrappers)
{
var targetParam = Expression.Parameter(typeof(Func<object[], object>), "orig");
var eventArgsParam = Expression.Parameter(typeof(AspectEventArgs), "event");
MethodInfo wrapperMethod;
if (typeof(Task).IsAssignableFrom(returnType))
{
var taskType = returnType.IsConstructedGenericType ? returnType.GenericTypeArguments[0] : _voidTaskResult;
returnType = typeof(Task<>).MakeGenericType(new[] { taskType });
wrapperMethod = _asyncGenericHandler.MakeGenericMethod(new[] { taskType });
}
else
{
if (returnType == typeof(void))
returnType = typeof(object);
wrapperMethod = _syncGenericHandler.MakeGenericMethod(new[] { returnType });
}
var converArgs = Expression.Parameter(typeof(object[]), "args");
var next = Expression.Lambda(Expression.Convert(Expression.Invoke(targetParam, converArgs), returnType), converArgs);
foreach (var wrapper in wrappers)
{
var argsParam = Expression.Parameter(typeof(object[]), "args");
next = Expression.Lambda(Expression.Call(Expression.Constant(wrapper), wrapperMethod, next, argsParam, eventArgsParam), argsParam);
}
var orig_args = Expression.Parameter(typeof(object[]), "orig_args");
var handler = Expression.Lambda<Handler>(Expression.Convert(Expression.Invoke(next, orig_args), typeof(object)), targetParam, orig_args, eventArgsParam);
var handlerCompiled = handler.Compile();
return handlerCompiled;
}
private Handler GetMethodHandler(MethodBase method, Type returnType, IReadOnlyList<BaseUniversalWrapperAttribute> wrappers)
{
var lazyHandler = _delegateCache.GetOrAdd((method, returnType), _ => new Lazy<Handler>(() => CreateMethodHandler(returnType, wrappers)));
return lazyHandler.Value;
}
}
public abstract class BaseUniversalWrapperAttribute : Attribute
{
protected internal virtual T WrapSync<T>(Func<object[], T> target, object[] args, AspectEventArgs eventArgs)
{
return target(args);
}
protected internal virtual Task<T> WrapAsync<T>(Func<object[], Task<T>> target, object[] args, AspectEventArgs eventArgs)
{
return target(args);
}
}
public abstract class BaseMethodPointsAspectAttribute : BaseUniversalWrapperAttribute
{
protected internal sealed override T WrapSync<T>(Func<object[], T> target, object[] args, AspectEventArgs eventArgs)
{
OnBefore(eventArgs);
try
{
var result = base.WrapSync(target, args, eventArgs);
OnAfter(eventArgs);
return result;
}
catch (Exception exception)
{
return OnException<T>(eventArgs, exception);
}
}
protected internal sealed override async Task<T> WrapAsync<T>(Func<object[], Task<T>> target, object[] args, AspectEventArgs eventArgs)
{
OnBefore(eventArgs);
try
{
var result = await target(args);
OnAfter(eventArgs);
return result;
}
catch (Exception exception)
{
return OnException<T>(eventArgs, exception);
}
}
protected virtual void OnBefore(AspectEventArgs eventArgs)
{
}
protected virtual void OnAfter(AspectEventArgs eventArgs)
{
}
protected virtual T OnException<T>(AspectEventArgs eventArgs, Exception exception)
{
throw exception;
}
}
public class AspectEventArgs : EventArgs
{
public object Instance { get; internal set; }
public Type Type { get; internal set; }
public MethodBase Method { get; internal set; }
public string Name { get; internal set; }
public IReadOnlyList<object> Args { get; internal set; }
public Type ReturnType { get; internal set; }
public Attribute[] Triggers { get; internal set; }
}
自定义切面类
用于限制参数长度，不符合条件的传参将修改返回值为错误信息。
[Aspect(Scope.Global)]
public class CommandLengthLimitAspect : BaseUniversalWrapperAspect
{
[Advice(Kind.Around, Targets = Target.Method)]
public object Handle(
[Argument(Source.Instance)] object instance,
[Argument(Source.Type)] Type type,
[Argument(Source.Metadata)] MethodBase method,
[Argument(Source.Target)] Func<object[], object> target,
[Argument(Source.Name)] string name,
[Argument(Source.Arguments)] object[] args,
[Argument(Source.ReturnType)] Type returnType,
[Argument(Source.Triggers)] Attribute[] triggers)
{
var trigger = triggers.OfType<CommandLengthLimitAttribute>().First();
var parameters = args[0] as List<string>;
if (parameters is not null && !trigger.LimitLengths.Contains(parameters.Count))
{
Func<object[], object> func = GetError;
return BaseHandle(instance, type, method, func, nameof(GetError), null, returnType, triggers);
}
return BaseHandle(instance, type, method, target, name, args, returnType, triggers);
}
private async Task<string> GetError(object obj)
{
await Task.CompletedTask;
return "错啦~";
}
}
自定义特性
[Injection(typeof(CommandLengthLimitAspect), Inherited = true)]
[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class CommandLengthLimitAttribute : BaseMethodPointsAspectAttribute
{
public int[] LimitLengths { get; }
public CommandLengthLimitAttribute(params int[] limitLengths) => LimitLengths = limitLengths;
}
使用示例
当commands长度不为1，Todo 方法返回的string结果将被篡改为错误信息。
[CommandLengthLimit(1)]
public async Task<string> Todo(List<string> commands)
{
// todo..
}