public void CanGetResult()
{
var mediator = new Mediator();
mediator.Subscribe<ChangeUserName, string>(message => new ReturnsName().Handle(message));
var command = new ChangeUserName { Name = "Foo Bar" };
var result = mediator.Send<ChangeUserName, string>(command);
Assert.AreEqual("Foo Bar", result);
}
public Controller(Mediator m, string name)
{
_name = name;
_mediator = m;
//assign the call back method
_mediator.SignOn(Notification);
}
protected override void ConfigureApplicationContainer(Nancy.TinyIoc.TinyIoCContainer container)
{
var mediator = new Mediator();
// mediator.Register<IHandleQueries<IQuery<User>, User>>(delegate
// {
// return new UserQueryHandler();
// });
//
// mediator.Register<ICommandHandler<ICommand<int>, int>>(delegate
// {
// return new InsertUserCommandHandler();
// }
// );
mediator.Register<IHandleQueries<IQuery<User>,User>, UserQueryHandler>();
mediator.Register<ICommandHandler<ICommand<int>,int>,UpdateUserCommandHandler>();
mediator.Register<ICommandHandler<ICommand<int>,int>,InsertUserCommandHandler>();
// mediator.Register<ICommandHandler<ICommand<int>, int>>(delegate
// {
// return new UpdateUserCommandHandler();
// }
// );
container.Register<IMediate,Mediator>(mediator);
}
public async Task ExecuteDeferredEvents_WhenCalled_ShouldCallAllEventHandlers()
{
// Arrange
var @event = new FakeEvent { Id = 1 };
var handlerFactory = new MessageHandlerRegistry();
var mediator = new Mediator(handlerFactory.MultiInstanceFactory, handlerFactory.SingleInstanceFactory);
handlerFactory.AddHandlersForEvent(new List<IEventHandler<FakeEvent>>
{
_autoSubstitute.SubstituteFor<HandlerDeferringMultipleEvents>(mediator),
_autoSubstitute.SubstituteFor<HandlerDeferringSingleEvent>(mediator),
_autoSubstitute.SubstituteFor<HandlerWithoutAdditionalEvents>()
});
mediator.DeferEvent(@event);
// Act
await mediator.ExecuteDeferredEvents();
// Assert
foreach (var handler in handlerFactory.GetHandlersFor<FakeEvent>())
{
handler.Received().Handle(Arg.Any<FakeEvent>()).FireAndForget();
}
}
static void Demo()
{
Mediator m = new Mediator();
Colleague chat1 = new Colleague(m, "John");
Colleague chat2 = new Colleague(m, "David");
Colleague chat3 = new Colleague(m, "Lucy");
}
public async Task ExecuteDeferredEvents_WhenCalled_ShouldExecuteEventHandlersForEventsFiredInHandlers()
{
// Arrange
var triggerEvent = new FakeEvent { Id = 1 };
var handlerFactory = new MessageHandlerRegistry();
var mediator = new Mediator(handlerFactory.MultiInstanceFactory, handlerFactory.SingleInstanceFactory);
handlerFactory.AddHandlersForEvent(new List<IEventHandler<FakeEvent>>
{
new HandlerDeferringMultipleEvents(mediator),
new HandlerDeferringSingleEvent(mediator),
new HandlerWithoutAdditionalEvents()
});
handlerFactory.AddHandlersForEvent(new List<IEventHandler<FakeEventFromHandler>>
{
new DependentEventHandler()
});
handlerFactory.AddHandlersForEvent(new List<IEventHandler<FakeEventTwoFromHandler>>
{
_autoSubstitute.SubstituteFor<ChainedEventHandler>()
});
// Act
mediator.DeferEvent(triggerEvent);
await mediator.ExecuteDeferredEvents();
// Assert
foreach (var handler in handlerFactory.GetHandlersFor<FakeEventTwoFromHandler>())
{
handler.Received(1).Handle(Arg.Any<FakeEventTwoFromHandler>()).FireAndForget();
}
}
public void DetermineIfEventHandlerIsRegistered()
{
var participants = new Participant[] {
new Participant("Participant 1"),
new Participant("Participant 2"),
new Participant("Participant 3")
};
IMediator mediator = null;
try {
mediator = new Mediator();
mediator.Register<ChatMessageEventArgs>(participants[0].OnRecieveMessage);
Assert.That(mediator.IsRegistered<ChatMessageEventArgs>(participants[0].OnRecieveMessage), Is.True);
Assert.That(mediator.IsRegistered<ChatMessageEventArgs>(participants[1].OnRecieveMessage), Is.False);
} finally {
for (int i = 0; i < participants.Length; i++) {
participants[i].Dispose();
}
var disposableMediator = mediator as IDisposable;
if(disposableMediator != null) {
disposableMediator.Dispose();
}
}
}
public void Examine()
{
Console.WriteLine("----------------------------------------");
Console.WriteLine("{0} | {1:n0} iterations", DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm"), Iterations);
Console.WriteLine("----------------------------------------");
var sw = Stopwatch.StartNew();
for (var i = 0; i < Iterations; i++)
{
}
sw.Stop();
Console.WriteLine("Baseline: {0}s | {1:n}/ms", sw.Elapsed.TotalSeconds, Math.Round(Iterations / sw.Elapsed.TotalMilliseconds, 2));
sw = Stopwatch.StartNew();
for (var i = 0; i < Iterations; i++)
{
new Counter().Handle(new DoIteration());
}
sw.Stop();
Console.WriteLine("Manual: {0}s | {1:n}/ms", sw.Elapsed.TotalSeconds, Math.Round(Iterations / sw.Elapsed.TotalMilliseconds, 2));
var mediator = new Mediator();
mediator.Subscribe<DoIteration>(message => new Counter().Handle(message));
sw = Stopwatch.StartNew();
for (var i = 0; i < Iterations; i++)
{
mediator.Send(new DoIteration());
}
sw.Stop();
Console.WriteLine("liason: {0}s | {1:n}/ms", sw.Elapsed.TotalSeconds, Math.Round(Iterations / sw.Elapsed.TotalMilliseconds, 2));
}
public void FinalizerEvent()
{
var participants = new Participant[] {
new Participant("Participant 1"),
new Participant("Participant 2"),
new Participant("Participant 3")
};
IMediator mediator = null;
try {
mediator = new Mediator();
mediator.Register<ChatMessageEventArgs>(participants[0].InterceptMessage);
mediator.RegisterFinalizer<ChatMessageEventArgs>(participants[2].OnRecieveMessage);
var args = new ChatMessageEventArgs("Hello there!");
mediator.Post(this, args);
Assert.That(participants[0].HasInterceptedMessageOnce(this, new ChatMessageEventArgs("Hello there!")), Is.True);
Assert.That(participants[2].HasReceivedMessageOnce(this, new ChatMessageEventArgs("Message has been intercepted.")), Is.True);
} finally {
for (int i = 0; i < participants.Length; i++) {
participants[i].Dispose();
}
var disposableMediator = mediator as IDisposable;
if(disposableMediator != null) {
disposableMediator.Dispose();
}
}
}
public void When_query_handler_throws_exception_should_propagate_exception()
{
var serviceContainer = new ServiceContainer();
serviceContainer.Register<IHandleRequests<QueryWithExcepetion, Response>, QueryWithExceptionHandler>();
var bus = new Mediator(serviceContainer.GetAllInstances);
Assert.Throws<InvalidOperationException>(() => bus.Send(new QueryWithExcepetion()));
}
public void When_command_handler_throws_exception_should_propagate_exception()
{
var serviceContainer = new ServiceContainer();
serviceContainer.Register<IHandleRequests<CommandWithException, Unit>, CommandHandlerThatThrowException>();
var bus = new Mediator(serviceContainer.GetAllInstances);
Assert.Throws<InvalidOperationException>(() => bus.Send(new CommandWithException()));
}
public void CanUseMediatorWithinHandler()
{
var mediator = new Mediator();
mediator.Subscribe<ProcessAccount>(message => new AccountExpiditer(mediator).Handle(message));
mediator.Subscribe<GetAccount, Account>(message => new AccountRepository().Handle(message));
mediator.Send(new ProcessAccount());
}
static void Main(string[] args)
{
var mediator = new Mediator(BuildContainer());
var testResponse = mediator.Send(new TestRequest());
_testTracker.Tracks.ToList().ForEach(Console.WriteLine);
}
public void When_event_handler_throws_exception_should_propagate_exception()
{
var serviceContainer = new ServiceContainer();
serviceContainer.Register<IHandleEvents<EventWithException>, EventWithExceptionHandler>();
var bus = new Mediator(serviceContainer.GetAllInstances);
Assert.Throws<InvalidOperationException>(() => bus.Publish(new EventWithException()));
}
/// <summary>
/// Adds a RabbitMQ Basic Consumer to the pipeline
/// </summary>
/// <param name="configurator"></param>
/// <param name="pipe"></param>
/// <param name="settings"></param>
/// <param name="receiveObserver"></param>
/// <param name="endpointObserver"></param>
/// <param name="exchangeBindings"></param>
/// <param name="taskSupervisor"></param>
/// <param name="mediator"></param>
public static void RabbitMqConsumer(this IPipeConfigurator<ConnectionContext> configurator, IPipe<ReceiveContext> pipe, ReceiveSettings settings, IReceiveObserver receiveObserver, IReceiveEndpointObserver endpointObserver, IEnumerable<ExchangeBindingSettings> exchangeBindings, ITaskSupervisor taskSupervisor, Mediator<ISetPrefetchCount> mediator)
{
if (configurator == null)
throw new ArgumentNullException(nameof(configurator));
var pipeBuilderConfigurator = new RabbitMqConsumerPipeSpecification(pipe, settings, receiveObserver, endpointObserver, exchangeBindings, taskSupervisor, mediator);
configurator.AddPipeSpecification(pipeBuilderConfigurator);
}
public async Task ExecuteDeferredEvents_WhenCalledWithoutEvent_ShouldNotThrow()
{
// Arrange
var handlerFactory = new MessageHandlerRegistry();
var mediator = new Mediator(handlerFactory.MultiInstanceFactory, handlerFactory.SingleInstanceFactory);
// Act
await mediator.ExecuteDeferredEvents();
}
public static void RegisterContainer()
{
var mediator = new Mediator();
var container = new Vessel();
container.Register<IMediator>(mediator);
container.Register<ISubscribeHandlers>(mediator);
container.RegisterModules();
DependencyResolver.SetResolver(new VesselDependencyResolver(container)); //for asp.net mvc
}
public RabbitMqReceiveEndpointConfigurator(IRabbitMqHost host, RabbitMqReceiveSettings settings, IConsumePipe consumePipe)
: base(consumePipe)
{
_host = host;
_settings = settings;
_mediator = new Mediator<ISetPrefetchCount>();
_exchangeBindings = new List<ExchangeBindingSettings>();
}
public void CanSubscribeAIntResultWithoutAFunc()
{
var mediator = new Mediator();
mediator.Subscribe<ChangeUserName, int>(message => new Returns42().Handle(message));
var command = new ChangeUserName { Name = "Foo Bar" };
var result = mediator.Send<ChangeUserName, int>(command);
Assert.AreEqual(42, result);
}
public void When_publishing_an_event_should_invoke_all_registered_event_handlers()
{
var serviceContainer = new ServiceContainer();
serviceContainer.RegisterAssembly(typeof(MediatorTests).Assembly, (serviceType, implementingType) => serviceType.IsGenericType && serviceType.GetGenericTypeDefinition() == typeof(IHandleEvents<>));
var bus = new Mediator(serviceContainer.GetAllInstances);
var message = new Event();
bus.Publish(message);
message.NumberOfTimesHandled.ShouldEqual(2);
}
public void CanSendWithoutResult()
{
var mediator = new Mediator();
var counter = new Counter();
mediator.Subscribe<ChangeUserName>(counter.Handle);
var command = new ChangeUserName { Name = "Foo Bar" };
mediator.Send(command);
Assert.AreEqual(1, counter.Count);
}
public RabbitMqReceiveEndpointConfigurator(IRabbitMqHost host, string queueName = null, IConsumePipe consumePipe = null)
: base(consumePipe)
{
_host = host;
_settings = new RabbitMqReceiveSettings
{
QueueName = queueName,
};
_mediator = new Mediator<ISetPrefetchCount>();
_exchangeBindings = new List<ExchangeBindingSettings>();
}
public void When_publishing_an_event_in_a_command_handler_should_handle_event()
{
var serviceContainer = new ServiceContainer();
var bus = new Mediator(serviceContainer.GetAllInstances);
serviceContainer.Register<IMediator>(sf => bus);
serviceContainer.Register<IHandleRequests<Command, Unit>, CommandHandlerThatSendsAnEvent>();
serviceContainer.Register<IHandleEvents<EventWithCommand>, EventWithCommandHandler>();
var command = new Command();
bus.Send(command);
command.IsHandled.ShouldBeTrue();
}
public void CanGetResultWithASecondVoidHandler()
{
var mediator = new Mediator();
mediator.Subscribe<ChangeUserName, string>(message =>
{
var r = new ReturnsName().Handle(message);
new ConsoleLogger().Handle(message);
return r;
});
var command = new ChangeUserName { Name = "Foo Bar" };
var result = mediator.Send<ChangeUserName, string>(command);
Assert.AreEqual("Foo Bar", result);
}
public void When_publishing_an_event_should_polymorphic_dispatch_to_all_handlers()
{
var serviceContainer = new ServiceContainer();
serviceContainer.Register<IHandleEvents<Event>, EventHandler>();
serviceContainer.Register<IHandleEvents<Event>, AnotherEventHandler>("Another");
var messageHandler = new MessageHandler();
serviceContainer.RegisterInstance<IHandleEvents<IEvent>>(messageHandler);
var bus = new Mediator(serviceContainer.GetAllInstances);
var message = new Event();
bus.Publish(message);
message.NumberOfTimesHandled.ShouldEqual(2);
messageHandler.IsHandled.ShouldBeTrue();
}
public RabbitMqReceiveTransport(IRabbitMqHost host, ReceiveSettings settings, Mediator<ISetPrefetchCount> mediator,
params ExchangeBindingSettings[] bindings)
{
_host = host;
_settings = settings;
_bindings = bindings;
_mediator = mediator;
_receiveObservable = new ReceiveObservable();
_receiveEndpointObservable = new ReceiveEndpointObservable();
var exceptionFilter = Retry.Selected<RabbitMqConnectionException>();
_connectionRetryPolicy = exceptionFilter.Exponential(1000, TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(1));
}
public void Main()
{
var m = new Mediator();
// Two from head office and one from a branch office
var head1 = new Colleague(m, "John");
var branch1 = new ColleagueB(m, "David");
var head2 = new Colleague(m, "Lucy");
head1.Send("Meeting on Tuesday, please all ack");
branch1.Send("Ack"); // by design does not get a copy
m.Block(branch1.Receive); // temporarily gets no messages
head1.Send("Still awaiting some Acks");
head2.Send("Ack");
m.Unblock(branch1.Receive); // open again
head1.Send("Thanks all");
}
// Call from native code
public static int Exec(string msg)
{
try
{
Thread.CurrentThread.SetApartmentState(ApartmentState.STA);
Image = new ImageHost();
Mediator = new Mediator();
Application = new App();
CoreMessage(msg);
Application.Run();
}
catch (Exception x)
{
MessageBox.Show(x.Message);
}
return 0;
}
public async Task ExecuteDeferredEvents_WhenCalledWithoutRegisteredHandlers_ShouldNotCallAnyHandlers()
{
// Arrange
var @event = new FakeEvent { Id = 1 };
var handlerFactory = new MessageHandlerRegistry();
var mediator = new Mediator(handlerFactory.MultiInstanceFactory, handlerFactory.SingleInstanceFactory);
mediator.DeferEvent(@event);
// Act
await mediator.ExecuteDeferredEvents();
// Assert
foreach (var handler in handlerFactory.GetHandlersFor<FakeEvent>())
{
handler.DidNotReceive().Handle(Arg.Any<FakeEvent>()).FireAndForget();
}
}
public async Task <IActionResult> GetAllCategories()
{
return(Ok(await Mediator.Send(new GetAllCategoriesQuery())));
}
/// <summary>
/// Required method for IXCoreColleague. As a colleague, it behaves exactly like its inner view.
/// </summary>
/// <param name="mediator"></param>
/// <param name="configurationParameters"></param>
public void Init(Mediator mediator, XmlNode configurationParameters)
{
m_innerView.Init(mediator, configurationParameters);
}
public async Task <ActionResult> Remove(RemovePlayerCommand command)
{
await Mediator.Send(command);
return(NoContent());
}
public async Task <ActionResult <int> > Create(CreateTodoItemCommand command)
{
return(await Mediator.Send(command));
}
public async Task <ActionResult <Unit> > Unattend(Guid id)
{
return(await Mediator.Send(new Unattend.Command {
Id = id
}));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Inits the specified mediator.
/// </summary>
/// <param name="mediator">The mediator.</param>
/// <param name="configurationParameters">The configuration parameters.</param>
/// ------------------------------------------------------------------------------------
public void Init(Mediator mediator, System.Xml.XmlNode configurationParameters)
{
}
public async Task <ActionResult <DeleteEtapaFenologicaResponse> > Delete(int id)
{
return(Ok(await Mediator.Send(new DeleteEtapaFenologicaCommand {
IdEtapa = id
})));
}
public async Task <IActionResult> Get(Guid id)
{
return(Ok(await Mediator.Send(new GetPositionByIdQuery {
Id = id
})));
}
public async Task <IActionResult> Index()
{
return(View(await Mediator.Send(new GetTemplateVariablesListQuery {
ProjectId = HttpContext.Request.Cookies.GetProjectId().Value
})));
}
public async Task <IActionResult> Get([FromQuery] GetPositionsQuery filter)
{
Log.Information($"GET Position called at {DateTime.Now}");
_loggerFactory.CreateLogger("GET Position called at");
return(Ok(await Mediator.Send(filter)));
}
public async Task <ActionResult <Unit> > Create(Create.Command command, CancellationToken ct)
{
return(await Mediator.Send(command, ct));
}
public async Task <ActionResult <int> > Create(CreateCrossPlayerGameTileCommand command)
{
return(await Mediator.Send(command));
}
public async Task <ActionResult <ActivityDto> > Details(Guid id, CancellationToken ct)
{
return(await Mediator.Send(new Details.Query {
Id = id
}, ct));
}
public async Task <ActionResult <GetEtapaFenologicaListResponse> > GetAllEtapas()
{
return(Ok(await Mediator.Send(new GetEtapaFenologicaListQuery())));
}
public async Task <ActionResult> Delete(int id)
{
await Mediator.Send(new DeleteTodoItemCommand { Id = id });
return(NoContent());
}
public async Task <ActionResult <Unit> > Delete(Guid id, CancellationToken ct)
{
return(await Mediator.Send(new Delete.Command {
Id = id
}, ct));
}
private void OnConfigCommand(object obj)
{
// need to get consumer to ask for spatial reference
Mediator.NotifyColleagues(CoordinateConversionLibrary.Constants.SelectSpatialReference, null);
}
private void FillTournaments()
{
lock (_lockerTimer)
{
SortableObservableCollection <IMatchVw> matches = new SortableObservableCollection <IMatchVw>();
matches = Repository.FindMatches(matches, "", SelectedLanguage, MatchFilter, Sort);
bool showSeparateOutrights = SelectedTournament != null && SelectedTournament.IsOutrightGroup;
if (!showSeparateOutrights)
{
var outrights = matches.Where(x => x.IsOutright).OrderBy(o => o.TournamentView.LineObject.GroupId).ToList();
if (outrights.Count > 0)
{
TournamentVw tournamentVw = null;
if (Tournaments.Count > 0 && Tournaments[0].IsOutrightGroup)
{
tournamentVw = Tournaments[0];
tournamentVw.Name = TranslationProvider.Translate(MultistringTags.OUTRIGHTS).ToString();
}
else
{
tournamentVw = new TournamentVw(int.MinValue, 0, TranslationProvider.Translate(MultistringTags.OUTRIGHTS).ToString(), 0, int.MinValue, null, "");
tournamentVw.IsOutrightGroup = true;
Tournaments.Insert(0, tournamentVw);
}
tournamentVw.TemporaryMatchesCount = outrights.Count;
}
}
var prematches = matches.Where(x => x.IsOutright == showSeparateOutrights).OrderBy(o => o.TournamentView.LineObject.GroupId).ToList();
foreach (var matchVw in prematches)
{
if (matchVw.TournamentView != null && matchVw.ExpiryDate > DateTime.Now)
{
TournamentVw tournamentVw = null;
int iTrmtIndex = Tournaments.IndexOf(new TournamentVw(matchVw.TournamentView.LineObject.GroupId));
if (iTrmtIndex >= 0)
{
tournamentVw = Tournaments[iTrmtIndex];
tournamentVw.Name = matchVw.TournamentView.DisplayName;
}
else
{
long countryId = -1;
string country = "";
if (matchVw.CountryView != null)
{
countryId = matchVw.CountryView.LineObject.SvrGroupId;
country = matchVw.CountryView.DisplayName;
}
//mv.TournamentView.LineObject.
string mincombination = null;
if (matchVw.TournamentView.LineObject.GroupTournament != null && matchVw.TournamentView.LineObject.GroupTournament.MinCombination.Value > 0)
{
mincombination = TranslationProvider.Translate(MultistringTags.TERMINAL_X_COMB, matchVw.TournamentView.LineObject.GroupTournament.MinCombination.Value);
}
tournamentVw = new TournamentVw(matchVw.TournamentView.LineObject.GroupId,
matchVw.TournamentView.LineObject.SvrGroupId,
matchVw.TournamentView.DisplayName,
countryId,
matchVw.TournamentView.LineObject.Sort.Value,
mincombination,
country);
if (matchVw.IsOutright)
{
tournamentVw.ContainsOutrights = true;
}
string id = tournamentVw.Id.ToString();
string tourId = matchVw.IsOutright ? id + "*1" : id + "*0";
if (ChangeTracker.SelectedTournaments.Contains(tourId))
{
tournamentVw.IsSelected = true;
}
Tournaments.Add(tournamentVw);
}
tournamentVw.AddMatch();
}
}
foreach (TournamentVw tournament in Tournaments)
{
tournament.ApplayTemporaryMatchesCount();
}
Tournaments.Sort(Comparison);
}
if (ChangeTracker.SelectedTournaments.Count == 0)
{
Mediator.SendMessage(true, MsgTag.ActivateForwardSelected);
}
else
{
Mediator.SendMessage(true, MsgTag.ActivateShowSelected);
}
}
public async Task <ActionResult <PaginatedList <TodoItemDto> > > GetTodoItemsWithPagination([FromQuery] GetTodoItemsWithPaginationQuery query)
{
return(await Mediator.Send(query));
}
public async Task <IActionResult> ToggleStatus(int id)
{
await Mediator.Send(new ToggleTemplateVariableStatusCommand { Id = id });
return(RedirectToAction("Index"));
}
public ConcreteColleague2(Mediator mediator)
: base(mediator)
{
}
public async Task <ActionResult <UserDetailsVm> > Get(int id)
{
return(View(await Mediator.Send(new GetUserDetailsQuery {
Id = id
})));
}
public async Task <IActionResult> GetVehicle(GetVehicle.Query query)
{
var result = await Mediator.Send(query);
return(Ok(result));
}
public async Task <IActionResult> BlockUser(int id)
{
await Mediator.Send(new BlockUserCommand { Id = id });
return(RedirectToAction(nameof(GetUserList)));
}
// [Authorize]
public async Task <IActionResult> Post(CreatePositionCommand command)
{
return(Ok(await Mediator.Send(command)));
}
public async Task <ActionResult <Unit> > Edit(Guid id, Edit.Command command, CancellationToken ct)
{
command.Id = id;
return(await Mediator.Send(command, ct));
}
// [Authorize]
public async Task <IActionResult> AddMock(InsertMockPositionCommand command)
{
return(Ok(await Mediator.Send(command)));
}
public async Task <ActionResult <MinifiedUserListVm> > GetMinifiedUserList()
{
return(View(await Mediator.Send(new GetMinifiedUserListQuery())));
}
public async Task <IActionResult> Delete(Guid id)
{
return(Ok(await Mediator.Send(new DeletePositionByIdCommand {
Id = id
})));
}
public Colleague(Mediator mediator)
{
this.mediator = mediator;
}
static void Main(string[] args)
{
var builder = new ContainerBuilder();
var executingAssembly = Assembly.GetExecutingAssembly();
//for debugging only
var tasks = executingAssembly.GetTypes().Where(t => t.Name.EndsWith("Task", StringComparison.Ordinal)).ToList();
builder.RegisterAssemblyTypes(executingAssembly)
.As(type => type.GetInterfaces()
.Where(interfaceType => interfaceType.IsClosedTypeOf(typeof (IRequestHandler<, >)))
.Select(interfaceType => new KeyedService("requestHandler", interfaceType))); // --> we need a keyed service as the decorated service will become the key-less one
//register the decorator - works
builder.RegisterGenericDecorator(typeof (LogHandler<, >), typeof (IRequestHandler<, >), "requestHandler", "decoratedWithLog");
builder.RegisterGenericDecorator(typeof (TransactionHandler<, >), typeof (IRequestHandler<, >), "decoratedWithLog"); //double logged! ->key-less
var container = builder.Build();
//get the original undecorated handler by using key
var commandUndec = container.ResolveKeyed<IRequestHandler<TestRequest, Unit>>("requestHandler");
commandUndec.Handle(new TestRequest{Title = "undecorated"});
Console.WriteLine();
//get the decorated one
var command = container.Resolve<IRequestHandler<TestRequest, Unit>>();
command.Handle(new TestRequest{Title = "decorated"});
Console.WriteLine();
//finally, use the mediator to resolve everything for us
var _mediator = new Mediator(container);
_mediator.Send(new TestRequest{Title = "Test"});
Console.ReadLine();
}
