public TResult Execute(TQuery query) { try { return(_decorated.Execute(query)); } catch (Exception ex) { Logger logger = LogManager.GetLogger(_decorated.GetType().ToString()); logger.Error(ex, "Exception occured"); throw; } }
private void CacheHandler(IQueryHandler handler) { Contract.Requires(handler != null); Contract.Ensures((handler.Reusable == false && GetCachedHandler(handler.GetType()) == null) || (handler.Reusable && _handlers[handler.GetType()] != null)); // if handler is reusable, cache if (handler.Reusable) { _handlers[handler.GetType()] = handler; } else { Contract.Assume(GetCachedHandler(handler.GetType()) == null); } }
public CacheQueryHandlerDecorator(IQueryCacheHandler <TQuery, TResult> cacheHandler, IQueryHandler <TQuery, TResult> decorated) { this.cacheHandler = cacheHandler; this.decorated = decorated; this.cachedAttribute = decorated.GetType().GetCustomAttribute <CachedAttribute>(); }
public async Task <TQueryResult> GetAsync(TQuery query, CancellationToken token) { var attr = _decoratee.GetType().GetMethod("GetAsync")?.GetCustomAttribute <CacheAttribute>(); if (attr == null) { return(await _decoratee.GetAsync(query, token)); } if (_cacheProvider is null) { return(await _decoratee.GetAsync(query, token)); } var cacheKey = $"{query.GetType().Name}_{query.AsDictionary(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).ToContentString()}"; //var cacheKey = CacheResultInterceptor.GetCacheKey(_decoratee.GetType(), "GetAsync", new object[] { query }); var result = _cacheProvider.Value.Get <TQueryResult>(cacheKey, attr.Region); if (result != null) { return(result); } result = await _decoratee.GetAsync(query, token); _cacheProvider.Value.Set(cacheKey, attr.Region, result, attr.Duration, attr.Slide); return(result); }
public async Task <TResult> Dispatch <TParameter, TResult>(TParameter query) where TParameter : class { IQueryHandler <TParameter, TResult> handler = provider.GetService(typeof(IQueryHandler <TParameter, TResult>)) as IQueryHandler <TParameter, TResult>; Log.Information(handler.GetType().ToString()); return(await handler.Retrieve(query)); }
/// <summary> /// Initializes a new instance of the <see cref="ReceiveMessageQueryDecorator" /> class. /// </summary> /// <param name="metrics">The metrics factory.</param> /// <param name="handler">The handler.</param> /// <param name="connectionInformation">The connection information.</param> public ReceiveMessageQueryDecorator(IMetrics metrics, IQueryHandler <ReceiveMessageQuery, RedisMessage> handler, IConnectionInformation connectionInformation) { Guard.NotNull(() => metrics, metrics); Guard.NotNull(() => handler, handler); var name = handler.GetType().Name; _counter = metrics.Counter($"{connectionInformation.QueueName}.{name}.HandleAsync.Expired", Units.Items); _handler = handler; }
public async Task <TProjection> HandleAsync(TQuery query, CancellationToken cancellationToken) { var queryName = query.GetType().FullName; var queryHandlerName = _decorated.GetType().FullName; var stopwatch = new Stopwatch(); try { stopwatch.Start(); return(await _decorated.HandleAsync(query, cancellationToken)); } catch (Exception exception) { var exceptionName = exception.GetType().FullName; _logger.LogWarning ( exception, "Exception {ExceptionName} thrown with message {ExceptionMessage} when handling query {QueryName} using handler {QueryHandlerName}", exceptionName, exception.Message, queryName, queryHandlerName ); throw; } finally { stopwatch.Stop(); var elapsed = stopwatch.Elapsed.TotalMilliseconds; _logger.LogInformation ( "Handled query {QueryName} using handler {QueryHandlerName} in {ElapsedMilliseconds}ms", queryName, queryHandlerName, elapsed ); _logger.LogDebug ( "{@Query}", query ); } }
public TResult Handle(TQuery query) { var result = _innerHandler.Handle(query); string resultString; try { resultString = result.ToJson(); } catch (Exception) { resultString = "{}"; } _logger.Info($"{query.GetType().Name} ====> {_innerHandler.GetType().Name}: {query.ToJson()} => {resultString}"); return(result); }