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(); }