private static string GetClassAndMethodName(IAsyncMethodInvocation methodInvocation)
{
var className = methodInvocation.TargetInstance.GetType().Name;
var methodWithUserName = $"{className}={methodInvocation.MethodInfo.Name}=";
return(methodWithUserName);
}
private static string GetParamWithValueKey(IAsyncMethodInvocation methodInvocation)
{
var childElementKey = string.Join(",", methodInvocation.Arguments
.Select(x => new StringBuilder($"{x.ParameterInfo.Name}|{x.Value}")));
return(childElementKey.IsNullOrWhiteSpace()
? GetClassAndMethodName(methodInvocation)
: childElementKey);
}
private static async Task <IMethodInvocationResult> SetCacheAndReturnAsync(IAsyncMethodInvocation methodInvocation, IDictionary <string, object> useCache, string keyName)
{
var resultIn = await methodInvocation.InvokeNextAsync();
//add to cache when it is a sucess call
resultIn.Successful.WhenTrue(() => useCache.Add(keyName, resultIn.ReturnValue));
return(resultIn);
}
public Task <IMethodInvocationResult> InterceptAsync(IAsyncMethodInvocation methodInvocation)
{
var scope = _methodIdentityProvider.BeginNextMethodIdentityScope(_mehodIdentityKey);
var res = methodInvocation.InvokeNextAsync();
res.ContinueWith(t => scope.Dispose());
return(res);
}
public async Task <IMethodInvocationResult> InterceptAsync(IAsyncMethodInvocation methodInvocation)
{
var argument = methodInvocation.GetArgument("value");
var argumentValue = (int)argument.Value;
if (argumentValue < 0)
{
argument.Value = -argumentValue;
}
return(await methodInvocation.InvokeNextAsync().ConfigureAwait(false));
}
public async Task <IMethodInvocationResult> InterceptAsync(IAsyncMethodInvocation methodInvocation)
{
var argument = methodInvocation.GetArgument("value");
var argumentValue = (int)argument.Value;
int result;
return(PrecalculatedValues.TryGetValue(argumentValue, out result)
? methodInvocation.CreateResult(result)
: await methodInvocation.InvokeNextAsync().ConfigureAwait(false));
}
private static bool IsValidMethodCall(IAsyncMethodInvocation methodInvocation)
{
var result = new RuleStatement <bool>(
() => methodInvocation.InstanceMethodInfo.ReturnType != typeof(void) &&
methodInvocation.MethodInfo.GetCustomAttributes <ResolveFromCacheAttribute>() != null,
new StopWithFuncRule <bool>(() => true), new StopWithFuncRule <bool>(() => false));
var isValid = result.Process();
return(isValid);
}
private async Task <IMethodInvocationResult> GetFromCacheAsync(IAsyncMethodInvocation methodInvocation)
{
var parentKey = GetClassAndMethodName(methodInvocation);
var useCache = cache.Get <IDictionary <string, object> >(parentKey)
.NoneWhenNullOrDefault(() => ResolveCacheDictionary(parentKey));
var keyName = GetParamWithValueKey(methodInvocation);
return(useCache.TryGetValue(keyName, out object cacheEntry)
? methodInvocation.CreateResult(cacheEntry)
: await SetCacheAndReturnAsync(methodInvocation, useCache, keyName));
}
public async Task <IMethodInvocationResult> InterceptAsync(IAsyncMethodInvocation methodInvocation)
{
var cache = methodInvocation.MethodInfo.GetCustomAttributes(typeof(Cached), false).FirstOrDefault();
if (cache != null)
{
var cacheObject = new MethodCacheObject(methodInvocation);
var cacheManager = AppCore.Instance.Get <ICacheStrategy <MethodCacheObject> >();
var cachedObject = cacheManager.MemoryCache.Get(cacheObject.Key).Result;
if (null != cachedObject)
{
if (DateTime.Now > cachedObject.Expiration)
{
cacheManager.MemoryCache.Remove(cachedObject.Key).Wait();
}
else
{
this.LogInformation($"{nameof(AsyncCachingInterceptor)} - {methodInvocation.MethodInfo.Name}");
return(methodInvocation.CreateResult(cachedObject.Value));
}
}
var result = await methodInvocation.InvokeNextAsync();
cacheObject.Value = result.GetReturnValueOrThrow();
if (null == cacheObject.Value)
{
return(result);
}
cacheObject.Expiration = DateTime.Now.AddMilliseconds(((Cached)cache).Duration);
await cacheManager.MemoryCache.Put(cacheObject.Key, cacheObject);
return(result);
}
return(await methodInvocation.InvokeNextAsync());
}
public async Task <IMethodInvocationResult> InterceptAsync(IAsyncMethodInvocation methodInvocation)
{
// BEFORE the target method execution
var methodInput = CreateMethodInput(methodInvocation);
var(msgInputLog, correlationState) = _methodLogMessageFactory.CreateInputMethodLogMessage(methodInput);
_logger.Info(msgInputLog);
try
{
// Yield to the next module in the pipeline
var result = await methodInvocation.InvokeNextAsync().ConfigureAwait(false);
// AFTER the target method execution
var methodReturn = new MethodReturn {
ReturnValue = result.ReturnValue
};
if (methodInvocation.ActualReturnType.Name == "Void")
{
methodReturn.ReturnValue = "Void";
}
var msgOutputLog = _methodLogMessageFactory.CreateOutputMethodLogMessage(methodReturn, correlationState);
_logger.Info(msgOutputLog);
return(result);
}
catch (Exception e)
{
var methodReturn = new MethodReturn {
Exception = e
};
var msgOutputLog = _methodLogMessageFactory.CreateOutputMethodLogMessage(methodReturn, correlationState);
_logger.Error(msgOutputLog);
throw;
}
}
public async Task <IMethodInvocationResult> InterceptAsync(IAsyncMethodInvocation methodInvocation)
{
if (methodInvocation.InstanceMethodInfo.Name != "IncrementAsync")
{
return(await methodInvocation.InvokeNextAsync());
}
if (_invoked)
{
throw new InvalidOperationException("Interceptor should be invoked once only");
}
_invoked = true;
IMethodInvocationResult result = null;
for (var i = 0; i < _retries; i++)
{
result = await methodInvocation.InvokeNextAsync().ConfigureAwait(false);
await Task.Delay(50).ConfigureAwait(false);
}
return(result);
}
public async Task<IMethodInvocationResult> InterceptAsync(IAsyncMethodInvocation methodInvocation)
{
return await methodInvocation.InvokeNextAsync().ConfigureAwait(false);
}
public async Task<IMethodInvocationResult> InterceptAsync(IAsyncMethodInvocation methodInvocation)
{
var argument = methodInvocation.GetArgument("value");
var argumentValue = (int)argument.Value;
int result;
return PrecalculatedValues.TryGetValue(argumentValue, out result)
? methodInvocation.CreateResult(result)
: await methodInvocation.InvokeNextAsync().ConfigureAwait(false);
}
public async Task<IMethodInvocationResult> InterceptAsync(IAsyncMethodInvocation methodInvocation)
{
var argument = methodInvocation.GetArgument("value");
var argumentValue = (int)argument.Value;
if (argumentValue < 0)
{
argument.Value = -argumentValue;
}
return await methodInvocation.InvokeNextAsync().ConfigureAwait(false);
}
public Task <IMethodInvocationResult> InterceptAsync(IAsyncMethodInvocation methodInvocation)
{
return(methodInvocation.InvokeNextAsync());
}
public async Task <IMethodInvocationResult> InterceptAsync(IAsyncMethodInvocation methodInvocation)
{
return(await CallWithOrWithoutCache[IsValidMethodCall(methodInvocation).ToString()]
.Invoke(methodInvocation));
}
public async Task <IMethodInvocationResult> InterceptAsync(IAsyncMethodInvocation methodInvocation)
{
return(await methodInvocation.InvokeNextAsync().ConfigureAwait(false));
}
private async static Task <IMethodInvocationResult> GetWithoutCacheAsync(IAsyncMethodInvocation methodInvocation) => await methodInvocation.InvokeNextAsync();
