/// <summary>
/// Publish the event.
/// </summary>
/// <param name="event">The event to publish.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
/// <param name="currentRequest">The current request. Pass null if there is not parent request.</param>
/// <returns>The result of the event.</returns>
internal async Task PublishAsync(IEvent @event, CancellationToken cancellationToken, HandlerRequest currentRequest)
{
if (@event == null)
{
throw Error.ArgumentNull("@event");
}
if (this.disposed)
{
throw new ObjectDisposedException(this.GetType().FullName);
}
if (currentRequest == null)
{
throw Error.InvalidOperation("The event '{0}' cannot be publish directly. Process a {1} then publish this event into the 'Handle' method.", @event.GetType().Name, typeof(ICommand).Name);
}
IEventStore eventStore = this.Configuration.Services.GetServiceOrThrow <IEventStore>();
await eventStore.StoreAsync(@event, cancellationToken);
IEventWorker eventWorker = this.Configuration.Services.GetEventWorker();
using (EventHandlerRequest request = new EventHandlerRequest(this.Configuration, @event, currentRequest))
{
request.Processor = new MessageProcessorWrapper(this, request);
await eventWorker.PublishAsync(request, cancellationToken);
}
}
public override IEventHandler CreateHandler(EventHandlerRequest request)
{
IEventHandler eventHandler = null;
this.traceWriter.TraceBeginEnd(
request,
TraceCategories.HandlersCategory,
TraceLevel.Info,
this.innerDescriptor.GetType().Name,
CreateHandlerMethodName,
beginTrace: null,
execute: () =>
{
eventHandler = this.innerDescriptor.CreateHandler(request);
},
endTrace: tr => tr.Message = eventHandler == null ? Resources.TraceNoneObjectMessage : this.innerDescriptor.HandlerType.FullName,
errorTrace: null);
if (eventHandler != null && !(eventHandler is EventHandlerTracer))
{
return(new EventHandlerTracer(request, eventHandler, this.traceWriter));
}
return(eventHandler);
}
public Task PublishAsync(EventHandlerRequest request, CancellationToken cancellationToken)
{
return(this.TraceWriter.TraceBeginEnd(
request,
TraceCategories.RequestsCategory,
TraceLevel.Info,
this.Inner.GetType().Name,
ExecuteMethodName,
beginTrace: null,
execute: () => this.Inner.PublishAsync(request, cancellationToken),
endTrace: null,
errorTrace: null));
}
EventHandlersDescriptor IEventHandlerSelector.SelectHandlers(EventHandlerRequest request)
{
EventHandlersDescriptor eventDescriptor = null;
this.traceWriter.TraceBeginEnd(
request,
TraceCategories.HandlersCategory,
TraceLevel.Info,
this.innerSelector.GetType().Name,
SelectActionMethodName,
beginTrace: null,
execute: () => eventDescriptor = this.innerSelector.SelectHandlers(request),
endTrace: tr =>
{
tr.Message = Error.Format(
Resources.TraceHandlerSelectedMessage,
FormattingUtilities.EventHandlerDescriptorsToString(eventDescriptor.EventHandlerDescriptors));
},
errorTrace: null);
Collection <EventHandlerDescriptor> handlerDescriptors = new Collection <EventHandlerDescriptor>();
foreach (var handlerDescriptor in eventDescriptor.EventHandlerDescriptors)
{
// Intercept returned EventHandlerDescriptor with a tracing version
if (handlerDescriptor != null && !(handlerDescriptor is EventHandlerDescriptorTracer))
{
handlerDescriptors.Add(new EventHandlerDescriptorTracer(handlerDescriptor, this.traceWriter));
}
else
{
handlerDescriptors.Add(handlerDescriptor);
}
}
return(new EventHandlersDescriptor(eventDescriptor.EventName, handlerDescriptors));
}
