public void Invoke(AspectContext container, AspectIntercept intercept)
{
if (intercept == AspectIntercept.Prolog)
{
var builder = new StringBuilder();
builder.Append(string.Format("{0} with Parameters: ", container.Name));
foreach (var param in container)
{
builder.Append(string.Format("{0} : {1} | ", param.Name, param.Value));
}
Console.WriteLine(builder.ToString());
}
if (intercept == AspectIntercept.Epilog)
{
Console.WriteLine(container.HasReturnValue
? string.Format("{0} returned with value {1}", container.Name, container.ReturnValue)
: string.Format("{0} returned", container.Name));
}
if (intercept == AspectIntercept.Exception)
{
Console.WriteLine(string.Format("EXCPETION in {0} with message: {1}", container.Name, container.Exception.Message));
container.IsHandeled = true;
}
}
public int LogChangedValue(AspectContext context)
{
var entity = (BaseEntity)context.Method.Args[0];
Dictionary<string, EntityColumn> changedColumns = entity.GetChangedColumns();
if (changedColumns.Count == 0)
return 0;
var logContext = new LogContext {EntityName = entity.EntityName, TableName = entity.TableName};
foreach (var c in changedColumns)
{
logContext.Values.Add(c.Key, new ChangedEntityColumn(c.Value.OldValue, c.Value.CurrentValue));
}
try
{
LogManager.Instance.Write(logContext, true);
}
catch (Exception exp)
{
throw exp;
}
return changedColumns.Count;
}
public async override Task Invoke(AspectContext context, AspectDelegate next)
{
try
{
Console.WriteLine("Before service call");
await next(context);//执行被拦截的方法
}
catch (Exception)
{
Console.WriteLine("Service threw an exception!");
throw;
}
finally
{
Console.WriteLine("After service call");
}
}
public override async Task Invoke(AspectContext context, AspectDelegate next)
{
var transaction = SmartSqlContainer.Instance.GetSmartSql(Alias).SqlMapper;
try
{
transaction.BeginTransaction();
await next.Invoke(context);
transaction.CommitTransaction();
}
catch (Exception ex)
{
transaction.RollbackTransaction();
throw ex;
}
}
/// <summary>
/// 方法参数放进字典
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
private Dictionary <string, object> GetParameterDictoryFromContext(AspectContext context)
{
var parameterDic = new Dictionary <string, object>();
var parameterInfos = context.ProxyMethod.GetParameters();
if (!parameterInfos.Any())
{
return(parameterDic);
}
for (var i = 0; i < parameterInfos.Length; i++)
{
parameterDic.Add(parameterInfos[i].Name, context.Parameters[i]);
}
return(parameterDic);
}
public async override Task Invoke(AspectContext context, AspectDelegate next)
{
await next.Invoke(context);
//Console.WriteLine($"______before->{context.ServiceMethod.Name}:Completed;DothingAfterExecuting");
if (context.ProxyMethod.Name.Contains("GetAsync"))
{
if (context.ReturnValue is Task <System.Collections.Generic.List <DBModel.Entity.TbUser> > )
{
var rtnVal = context.ReturnValue as Task <System.Collections.Generic.List <DBModel.Entity.TbUser> >;
rtnVal.Result.Add(new DBModel.Entity.TbUser()
{
Name = "Test"
});
}
}
}
/// <summary>
/// 执行后
/// </summary>
/// <param name="log">日志操作</param>
/// <param name="context">Aspect上下文</param>
/// <param name="methodName">方法名</param>
private async Task ExecuteAfter(ILog log, AspectContext context, string methodName)
{
if (context.ServiceMethod.ReturnType == typeof(Task) ||
context.ServiceMethod.ReturnType == typeof(void) ||
context.ServiceMethod.ReturnType == typeof(ValueTask))
{
return;
}
var returnValue = context.IsAsync() ? await context.UnwrapAsyncReturnValue() : context.ReturnValue;
var returnType = returnValue.GetType().FullName;
log.Caption($"{context.ServiceMethod.Name}方法执行后")
.Method(methodName)
.Content($"返回类型: {returnType}, 返回值: {returnValue.SafeString()}");
WriteLog(log);
}
/// <summary>
/// 执行
/// </summary>
public override async Task Invoke(AspectContext context, AspectDelegate next)
{
await next(context);
var manager = context.ServiceProvider.GetService <IUnitOfWorkManager>();
if (manager == null)
{
return;
}
await manager.CommitAsync();
if (context.Implementation is ICommitAfter service)
{
service.CommitAfter();
}
}
public override async Task Invoke(AspectContext context, AspectDelegate next)
{
var sessionStore = context.ServiceProvider.GetSessionStore(Alias);
if (sessionStore == null)
{
throw new SmartSqlException($"can not find SmartSql instance by Alias:{Alias}.");
}
var inTransaction = sessionStore.LocalSession?.Transaction != null;
if (inTransaction)
{
await next.Invoke(context); return;
}
using (sessionStore)
using (var dbSession = sessionStore.Open())
{
try
{
dbSession.BeginTransaction(Level);
await next.Invoke(context);
var canCommit = true;
if (CommitWhenReturnTrue)
{
canCommit = context.ServiceMethod.ReturnType == typeof(bool) && true == (bool)context.ReturnValue;
}
if (canCommit)
{
dbSession.CommitTransaction();
}
else
{
dbSession.RollbackTransaction();
}
}
catch (Exception ex)
{
dbSession.RollbackTransaction();
throw ex;
}
}
}
public override async Task Invoke(AspectContext context, AspectDelegate next)
{
_ = context ?? throw new ArgumentNullException(nameof(context));
_ = next ?? throw new ArgumentNullException(nameof(next));
var mongoContext = GetCurrentMongoContext(context);
if (mongoContext == null)
{
var logger =
context.ServiceProvider.GetService(
typeof(ILogger <>).MakeGenericType(context.ImplementationMethod.DeclaringType)) as ILogger;
logger.LogWarning($"Can not find mongo context in current type '{context.ImplementationMethod.DeclaringType}', {nameof(TransactionAttribute)} will be ignored.");
await next?.Invoke(context);
return;
}
bool started = false;
try
{
started = StartTransaction(mongoContext);
await next?.Invoke(context);
if (started)
{
CommitTransaction(mongoContext);
}
}
catch
{
if (started)
{
RollbackTransaction(mongoContext);
}
throw;
}
finally
{
if (started)
{
ResetTransaction(mongoContext);
}
}
}
public async override Task Invoke(AspectContext context, AspectDelegate next)
{
var cachedConfigurationProvider = context.ServiceProvider.GetService <IOptionsMonitor <FilterCachedConfiguration> >();
var configCache = context.GetCacheConfigurationByMethodName(cachedConfigurationProvider.CurrentValue);
var methodReturnType = context.ProxyMethod.ReturnType;
if (
configCache == null ||
methodReturnType == typeof(void) ||
methodReturnType == typeof(Task) ||
methodReturnType == typeof(ValueTask)
)
{
await next(context);
return;
}
if (string.IsNullOrWhiteSpace(CacheName))
{
CacheName = context.GetGenerateKeyByMethodNameAndValues();
}
ResponseCacheService = context.ServiceProvider.GetService <IResponseCacheService>();
var returnType = context.IsAsync() ? methodReturnType.GenericTypeArguments.FirstOrDefault() : methodReturnType;
var cachedValue = await ResponseCacheService.GetCachedResponseAsync(CacheName, returnType);
if (cachedValue != null)
{
context.SetReturnType(methodReturnType, cachedValue);
return;
}
await next(context);
await ResponseCacheService
.SetCacheResponseAsync(
CacheName,
await context.GetReturnValueAsync(),
TimeSpan.FromSeconds(configCache.TimeToLiveSeconds ?? TimeToLiveSeconds)
);
}
public Task Invoke(AspectContext context, AspectDelegate next)
{
try
{
// Buraya yazılan kodlar before
return(next.Invoke(context).ContinueWith(task =>
{
// buraya yazılan kodlar finish
}));
}
catch (Exception ex)
{
//log ex yazdır.
throw;
}
}
public override async Task Invoke(AspectContext context, AspectDelegate next)
{
try
{
await next(context);//执行被拦截的方法
}
catch (Exception ex)
{
//context.ServiceMethod被拦截的方法。context.ServiceMethod.DeclaringType被拦截方法所在的类
//context.Implementation实际执行的对象p
//context.Parameters方法参数值
//如果执行失败，则执行FallBackMethod
var fallBackMethod = context.ServiceMethod.DeclaringType.GetMethod(this.FallBackMethod);
Object fallBackResult = fallBackMethod.Invoke(context.Implementation, context.Parameters);
context.ReturnValue = fallBackResult;
await Task.FromResult(0);
}
}
public async override Task Invoke(AspectContext context, AspectDelegate next)
{
var logger = context.ServiceProvider.GetService(typeof(ILogger <SystemLogsAttribute>)) as ILogger <SystemLogsAttribute>;
dynamic paramObj = context.Parameters.FirstOrDefault();
string param = JsonConvert.SerializeObject(paramObj);
string key = "Param:" + param;
logger.LogInformation(key);
try
{
await next(context);
}
catch (Exception ex)
{
logger.LogError(ex.Message);
throw;
}
}
public async Task Process()
{
var data = await ActualWordsHandler.InstanceSimple.TextSplitter.Process(new ParseRequest("I like my school teacher.")).ConfigureAwait(false);
var document = data.Construct(ActualWordsHandler.InstanceSimple.WordFactory);
var review = ActualWordsHandler.InstanceSimple.Container.Resolve <Func <Document, IParsedReviewManager> >()(document).Create();
var context = new AspectContext(true, review.ImportantWords.ToArray());
context.Process();
var attributes = context.GetAttributes().ToArray();
var features = context.GetFeatures().ToArray();
Assert.AreEqual(1, attributes.Length);
Assert.AreEqual("like", attributes[0].Text);
Assert.AreEqual(2, features.Length);
Assert.IsTrue(features.Any(item => item.Text == "school"));
Assert.IsTrue(features.Any(item => item.Text == "teacher"));
}
public override async Task Invoke(AspectContext context, AspectDelegate next)
{
using (var trans = DbContext.Database.BeginTransaction())
{
try
{
await next(context);
DbContext.SaveChanges();
trans.Commit();
}
catch (Exception)
{
trans.Rollback();
throw;
}
}
}
public IAspectBuilder Create(AspectContext context)
{
var aspectBuilder = new AspectBuilder(ctx => ctx.Complete(), null);
foreach (var interceptor in _interceptorCollector.Collect(context.ServiceMethod, context.ImplementationMethod))
{
if (interceptor is IScopeInterceptor scopedInterceptor)
{
if (!_aspectContextScheduler.TryRelate(context as ScopeAspectContext, scopedInterceptor))
{
continue;
}
}
aspectBuilder.AddAspectDelegate(interceptor.Invoke);
}
return(aspectBuilder);
}
public override async Task Invoke(AspectContext context, AspectDelegate next)
{
var parameters = context.GetParameters();
var param = parameters.FirstOrDefault(x => x.ParameterInfo.GetCustomAttribute <FromCapAttribute>() != null);
if (param == null)
{
await next(context);
return;
}
if (param.Value is CapHeader capHeader)
{
InitTraceIdContext(capHeader);
await next(context);
}
}
/// <summary>
/// 执行
/// </summary>
/// <returns></returns>
public override async Task Invoke(AspectContext context, AspectDelegate next)
{
var cacheKey = GenerateCacheKey(context, ParamCount);
var type = context.ServiceMethod.ReturnType;
var cacheValue = CacheProvider.Get(cacheKey, type);
if (cacheValue.HasValue)
{
context.ReturnValue = cacheValue.Value;
return;
}
await next(context);
if (!string.IsNullOrWhiteSpace(cacheKey))
{
CacheProvider.Set(cacheKey, context.ReturnValue, TimeSpan.FromSeconds(Expiration));
}
}
public async override Task Invoke(AspectContext context, AspectDelegate next)
{
try
{
Logger.LogInformation($"{context.Implementation}. { context.ProxyMethod.Name} 开始执行！");
SetTokenValue(context);
await next(context);
}
catch (Exception exc)
{
Logger.LogError($"异常发生：{exc.Message}");
throw exc;
}
finally
{
Logger.LogInformation($"{context.Implementation}. { context.ProxyMethod.Name} 执行结束！");
}
}
public override Task Invoke(AspectContext context, AspectDelegate next)
{
if (string.IsNullOrEmpty(Sql))
{
throw new ArgumentNullException(nameof(Sql));
}
var paramters = context.GetParameters();
var queryParams = ToParamterDict(paramters);
using (var conn = ConnectionFactory.CreateConnection(ConnectionName))
{
var result = QueryHelper.RunGenericCount(context.ServiceMethod.ReturnType, conn, Sql, queryParams);
context.ReturnValue = result;
}
return(context.Break());
}
public override async Task Invoke(AspectContext context, AspectDelegate next)
{
var sw = Stopwatch.StartNew();
if (Env.IsDevelopment)
{
for (int i = 0; i < ExecuteCount; i++)
{
await context.Invoke(next);
}
}
else
{
await context.Invoke(next);
}
sw.Stop();
Logger.LogWarning($"【{context.Implementation}.{context.ServiceMethod.Name}】【params:{string.Join(",", context.Parameters)}】:{sw.ElapsedMilliseconds}ms");
}
public override async Task Invoke(AspectContext context, AspectDelegate next)
{
await using var tran =
EfNestedTransactionContext.BeginNestedTransaction(DbContextType, context.ServiceProvider, IsolationLevel);
try
{
await next(context);
await tran.CommitAsync();
}
catch
{
await tran.RollbackAsync();
throw;
}
}
public override async Task Invoke(AspectContext context, AspectDelegate next)
{
try
{
var unitOfWork = (IUnitOfWork)context.ServiceProvider.GetService(typeof(IUnitOfWork));
if (unitOfWork.IsNotNull())
{
await unitOfWork.UseTransactionAsync(async() =>
{
await next(context);
});
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task Invoke(AspectContext context, AspectDelegate next)
{
var _uowHelper = context.ServiceProvider.Resolve <IUowHelper>();
if (_uowHelper.IsExistUow)
{
await next(context);
}
else
{
using (var uow = _uowHelper.Create())
{
await next(context);
uow.Commit();
}
}
}
public override Task Invoke(AspectContext context, AspectDelegate next)
{
var impType = context.Implementation.GetType();
var properties = impType.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
.Where(p => p.IsDefined(typeof(FromDbOptionAttribute))).ToList();
if (properties.Any())
{
var options = context.ServiceProvider.GetServices <IOptions <DbContextOption> >().ToList();
foreach (var property in properties)
{
var attribute = property.GetCustomAttribute <FromDbOptionAttribute>();
var option = options.FirstOrDefault(m => m.Value.TagName == attribute.TagName);
property.SetValue(context.Implementation, option);
}
}
return(context.Invoke(next));
}
/// <summary>
/// 执行
/// </summary>
public override async Task Invoke(AspectContext context, AspectDelegate next)
{
var methodName = GetMethodName(context);
var log = Log.GetLog(methodName);
try {
await next(context);
}
catch (Exception ex) {
log.Class(context.ServiceMethod.DeclaringType.FullName).Method(methodName).Exception(ex);
foreach (var parameter in context.GetParameters())
{
parameter.AppendTo(log);
}
log.Error();
throw;
}
}
public override async Task Invoke(AspectContext context, AspectDelegate next)
{
var parameters = context.ServiceMethod.GetParameters();
//判断Method是否包含ref / out参数
if (parameters.Any(it => it.IsIn || it.IsOut))
{
await next(context);
}
else
{
var key = string.IsNullOrEmpty(CacheKey)
? new CacheKey(context.ServiceMethod, parameters, context.Parameters).GetRedisCacheKey()
: CacheKey;
var value = await DistributedCacheManager.GetAsync(key);
if (value != null)
{
if (context.ServiceMethod.IsReturnTask())
{
dynamic result = JsonConvert.DeserializeObject(value,
context.ServiceMethod.ReturnType.GenericTypeArguments[0]);
context.ReturnValue = Task.FromResult(result);
}
else
{
context.ReturnValue = JsonConvert.DeserializeObject(value, context.ServiceMethod.ReturnType);
}
}
else
{
await context.Invoke(next);
dynamic returnValue = context.ReturnValue;
if (context.ServiceMethod.IsReturnTask())
{
returnValue = returnValue.Result;
}
await DistributedCacheManager.SetAsync(key, returnValue, Expiration);
//await next(context);
}
}
}
private AsyncPolicy BuildPolicy(AspectContext context, AsyncPolicy policy)
{
if (policy != null)
{
return(policy);
}
policy = Policy.NoOpAsync();
if (IsEnableCircuitBreaker)
{
policy = policy.WrapAsync(Policy.Handle <Exception>().CircuitBreakerAsync(
ExceptionsAllowedBeforeBreaking,
TimeSpan.FromMilliseconds(MillisecondsOfBreak)));
}
if (TimeOutMilliseconds > 0)
{
policy = policy.WrapAsync(Policy.TimeoutAsync(() => TimeSpan.FromMilliseconds(TimeOutMilliseconds),
Polly.Timeout.TimeoutStrategy.Pessimistic));
}
if (MaxRetryTimes > 0)
{
policy = policy.WrapAsync(Policy.Handle <Exception>().WaitAndRetryAsync(MaxRetryTimes,
i => TimeSpan.FromMilliseconds(RetryIntervalMilliseconds)));
}
var policyFallBack = Policy
.Handle <Exception>()
.FallbackAsync((ctx, t) =>
{
var aspectContext = (AspectContext)ctx["aspectContext"];
var fallBackMethod = context.ServiceMethod?.DeclaringType?.GetMethod(FallBackMethod);
var fallBackResult = fallBackMethod?.Invoke(context.Implementation, context.Parameters);
aspectContext.ReturnValue = fallBackResult;
return(Task.FromResult(fallBackResult));
}, async(ex, t) => throw ex);
policy = policyFallBack.WrapAsync(policy);
policies.TryAdd(context.ServiceMethod, policy);
return(policy);
}
/// <summary>执行拦截业务，并根据返回结果决定提交事务还是回滚</summary>
/// <param name="context">切面上下文</param>
/// <param name="next">被拦截并包装的操作</param>
public override async Task Invoke(AspectContext context, AspectDelegate next)
{
IServiceProvider provider = context.ServiceProvider;
IUnitOfWorkManager unitOfWorkManager = provider.GetService <IUnitOfWorkManager>();
try
{
await next(context);
if (!RequiredCheckReturnValue)
{
#if NET5_0
await unitOfWorkManager.CommitAsync();
#else
unitOfWorkManager.Commit();
#endif
return;
}
Type returnType = context.ProxyMethod.ReturnType;
ITransactionDecision decision = provider.GetServices <ITransactionDecision>()
.FirstOrDefault(m => m.IsFit(returnType));
if (decision == null)
{
throw new OsharpException($"无法找到与结果类型 {returnType} 匹配的 {typeof(ITransactionDecision)} 事务裁决器，请继承接口实现一个");
}
if (decision.CanCommit(context.ReturnValue))
{
#if NET5_0
await unitOfWorkManager.CommitAsync();
#else
unitOfWorkManager.Commit();
#endif
}
}
catch (Exception)
{
#if NET5_0
await unitOfWorkManager.CommitAsync();
#else
unitOfWorkManager.Commit();
#endif
throw;
}
}
public async override Task Invoke(AspectContext context, AspectDelegate next)
{
if (!IsOpen || Seconds <= 0)
{
await next(context);
return;
}
try
{
var cacheService = context.ServiceProvider.GetService <ICacheService>();
Type returnType = context.GetReturnType();
string key = Utils.GetParamterKey(Prefix, Key, ParamterKey, context.Parameters);
var result = cacheService.Get(key, returnType);
if (result == null)
{
await next(context);
var value = await context.GetReturnValue();
if (value != null)
{
cacheService.Set(key, TimeSpan.FromSeconds(Seconds), value);
}
}
else
{
context.ReturnValue = context.ResultFactory(result, returnType, context.IsAsync());
}
}
catch (Exception ex)
{
var logger = context.ServiceProvider.GetService <ILogger <CacheMethodAttribute> >();
logger.LogError($"CacheMethod：Key：{Key}，ParamterKey：{ParamterKey} {ex.FormatMessage()}");
await next(context);
}
}
public override async Task Invoke(AspectContext context, AspectDelegate next)
{
var logger = context.ServiceProvider.GetService <ILogger <CustomInterceptorAttribute> >();
try
{
logger.LogDebug("Before invoke");
await next(context);
}
catch (Exception ex)
{
logger.LogError($"Exception is {ex}");
throw;
}
finally
{
logger.LogDebug("After inovke");
}
}
public void Invoke(AspectContext container, AspectIntercept intercept)
{
this.InvokeInternal(container, intercept);
}
public object Manipulate(AspectContext container, AspectIntercept intercept)
{
var ret = this.ManipulateInternal(container, intercept);
container.IsManipulated = true;
return ret;
}
protected abstract void InvokeInternal(AspectContext container, AspectIntercept intercept);
protected abstract object ManipulateInternal(AspectContext container, AspectIntercept intercept);
public void Invoke(AspectContext container, AspectIntercept intercept)
{
container.Implementation();
}