internal async Task <TResult> Handle(IQuery <TResult> query, CancellationToken cancellationToken)
{
IQueryHandler <TQuery, TResult> handler = await _queryHandlerProvider.GetHandler <TQuery, TResult>();
if (handler == null)
{
throw new InvalidOperationException($"There isn't any registered query handler for {typeof(TQuery).Name}");
}
IEnumerable <IQueryMiddleware <TQuery, TResult> > middlewares = await _queryMiddlewareProvider.GetMiddlewares <TQuery, TResult>();
async Task <TResult> pipelineEnd()
{
return(await handler.Handle((TQuery)query, cancellationToken));
}
NextMiddlewareDelegate <TResult> pipeline = middlewares
.Reverse()
.Aggregate((NextMiddlewareDelegate <TResult>)pipelineEnd, (next, middleware) =>
{
return(async delegate
{
return await middleware.Invoke((TQuery)query, cancellationToken, next);
});
});
return(await pipeline());
}
/// <summary>
/// Dispatchs an event into configured dispatch strategy
/// </summary>
/// <typeparam name="TEvent">Event type</typeparam>
/// <param name="event">Event data</param>
/// <param name="cancellationToken">Cancellation token</param>
/// <returns></returns>
public async Task Dispatch <TEvent>(TEvent @event, CancellationToken cancellationToken)
where TEvent : IEvent
{
if (@event == null)
{
throw new ArgumentNullException(nameof(@event));
}
IEnumerable <IEventHandler <TEvent> > handlers = await _eventHandlerProvider.GetHandlers <TEvent>();
if (!handlers.Any())
{
throw new InvalidOperationException($"There isn't any registered event handler for {typeof(TEvent).Name}");
}
IEnumerable <IEventMiddleware <TEvent> > middlewares = await _eventMiddlewareProvider.GetMiddlewares <TEvent>();
async Task pipelineEnd()
{
await _eventDispatchStrategy.Dispatch(@event, handlers, cancellationToken);
}
NextMiddlewareDelegate pipeline = middlewares
.Reverse()
.Aggregate((NextMiddlewareDelegate)pipelineEnd, (next, middleware) =>
{
return(async delegate
{
await middleware.Invoke(@event, cancellationToken, next);
});
});
await pipeline();
}
public async Task Invoke(TEvent @event, CancellationToken cancellationToken, NextMiddlewareDelegate next)
{
//example validation
if (@event.EventId == Guid.Empty)
{
//example exception for this example
throw new InvalidOperationException("The event id must be not null");
}
await next();
}
public async Task <TResult> Invoke(TQuery query, CancellationToken cancellationToken, NextMiddlewareDelegate <TResult> next)
{
//example validation
if (query.QueryId != Guid.Empty)
{
return(await next());
}
//example exception for this example
throw new InvalidOperationException("The query id must be not null");
}
public async Task Invoke(SampleComplexEvent @event, CancellationToken cancellationToken, NextMiddlewareDelegate next)
{
@event.EventData += " [modified from middleware]";
await next();
}
public async Task <SampleComplexQueryResponse> Invoke(SampleComplexQuery query, CancellationToken cancellationToken, NextMiddlewareDelegate <SampleComplexQueryResponse> next)
{
query.QueryData += " I'm using Mediate";
SampleComplexQueryResponse response = await next();
response.QueryResponseData += " [modified from middleware]";
return(response);
}
