C# EventAggregator.Publish方法代码示例

        public void ObserverShouldOnlyReceiveSubscribedNotifications()
        {
            // Arrange

            var eventAggregator = new EventAggregator();
            var observer1 = new Mock<IObserve<TestEvent>>();
            var observer2 = new Mock<IObserve<OtherEvent>>();

            eventAggregator.Subscribe(observer1.Object);
            eventAggregator.Subscribe(observer2.Object);

            var testEvent = new TestEvent();
            var otherEvent = new OtherEvent();

            // Act

            eventAggregator.Publish(testEvent);
            eventAggregator.Publish(otherEvent);

            // Assert

            observer1.Verify(x => x.OnNext(It.IsAny<IEvent>()), Times.Once);
            observer1.Verify(x => x.OnNext(testEvent), Times.Once);
            observer2.Verify(x => x.OnNext(otherEvent), Times.Once);
        }

        public void Context()
        {
            _session = MockRepository.GenerateMock<ISession>();
            _session.Stub(x => x.Save(Arg<object>.Is.NotNull))
                .WhenCalled(x => _saved.Add(x.Arguments.First()));
            var container = IoC.Container;
            container.Configure(x => x.For<ISession>().Use(_session));
            var eventAggregator = new EventAggregator(container);

            eventAggregator.Publish(new SubscriptionCreated());
        }

        public void SubscriberShouldReceiveMessage_WhenMessagePublished()
        {
            var mock = new Mock<ISubscriber<Message1>>();
            var eventAggregator = new EventAggregator();

            eventAggregator.Subscribe(mock.Object);
            var msg = new Message1();
            eventAggregator.Publish(msg);

            mock.Verify(s => s.Handle(msg));
        }

        public void SubscriberShouldNotReceiveMessageWhichItIsNotSubscribedTo()
        {
            var mock = new Mock<ISubscriber<Message1>>();
            var eventAggregator = new EventAggregator();

            eventAggregator.Subscribe(mock.Object);
            var msg = new Message2();
            eventAggregator.Publish(msg);

            mock.Verify(s => s.Handle(It.IsAny<Message1>()), Times.Never());
        }

        public void Subscribe_WhenGivenEvent_ShouldRaiseEvent()
        {
            var eventWasRaised = false;
            var eventBus = new EventAggregator();

            eventBus.GetEvent<TestEvent>().Subscribe(new Observer<TestEvent>(x => eventWasRaised = true));

            eventBus.Publish(new TestEvent());

            Assert.IsTrue(eventWasRaised);
        }

        public void Unsubscribe_WhenGivenEvent_ShouldNotRaiseEvent()
        {
            var eventWasRaised = false;
            var eventBus = new EventAggregator();

            var subscription = eventBus.GetEvent<TestEvent>().Subscribe(new Observer<TestEvent>(x => eventWasRaised = true));

            subscription.Dispose();
            eventBus.Publish(new TestEvent());

            Assert.IsFalse(eventWasRaised);
        }

        public void ObserverStopsReceivingEventsWhenUnsubscribed()
        {
            // Arrange

            var eventAggregator = new EventAggregator();
            var observer1 = new Mock<IObserve<TestEvent>>();

            var unsubscribe = eventAggregator.Subscribe(observer1.Object);
            var testEvent1 = new TestEvent();
            var testEvent2 = new TestEvent();

            // Act

            eventAggregator.Publish(testEvent1);
            unsubscribe.Dispose();
            eventAggregator.Publish(testEvent2);

            // Assert

            observer1.Verify(x => x.OnNext(It.IsAny<IEvent>()), Times.Once);
            observer1.Verify(x => x.OnNext(testEvent1), Times.Once);
            observer1.Verify(x => x.OnNext(testEvent2), Times.Never);
        }

        public void BaseObserverReceivesAllEvents()
        {
            // Arrange

            var eventAggregator = new EventAggregator();
            var observer1 = new Mock<IObserve<IEvent>>();
            var observer2 = new Mock<IObserver<IEvent>>();

            eventAggregator.Subscribe(observer1.Object);
            eventAggregator.Subscribe(observer2.Object);

            var testEvent = new TestEvent();
            var otherEvent = new OtherEvent();

            // Act

            eventAggregator.Publish(testEvent);
            eventAggregator.Publish(otherEvent);

            // Assert

            observer1.Verify(x => x.OnNext(It.IsAny<IEvent>()), Times.Exactly(2));
            observer2.Verify(x => x.OnNext(It.IsAny<IEvent>()), Times.Exactly(2));
        }

        public void testing_subscribe()
        {
            // arrange
            var eventWasRaised = false;
            var eventPublisher = new EventAggregator();

            // act
            eventPublisher.GetEvent<SampleEvent>()
                .Subscribe(se => eventWasRaised = true);

            eventPublisher.Publish(new SampleEvent());
            
            // assert
            eventWasRaised.ShouldBe(true);
        }

        public void A_valid_message_is_published_to_all_handlers() {
            var eventAggregator = new EventAggregator();
            var handlerMockA = new Mock<IHandle<object>>();
            var handlerMockB = new Mock<IHandle<object>>();


            eventAggregator.Subscribe(handlerMockA.Object);
            eventAggregator.Subscribe(handlerMockB.Object);
            eventAggregator.Publish(new object());

            handlerMockA.Verify(handlerStub => handlerStub.Handle(It.IsAny<object>()),
                                Times.AtLeastOnce());
            handlerMockB.Verify(handlerStub => handlerStub.Handle(It.IsAny<object>()),
                                Times.AtLeastOnce());

        }

        public void testing_selective_subscribe_ignored()
        {
            // arrange
            var eventWasRaised = false;
            var eventPublisher = new EventAggregator();

            // act
            eventPublisher.GetEvent<SampleEvent>()
                .Where(se => se.Status != 1)
                .Subscribe(se => eventWasRaised = true);

            eventPublisher.Publish(new SampleEvent { Status = 1 });

            // assert
            eventWasRaised.ShouldBe(false);
        }

        public ShellViewModel(EventAggregator eventAggregator, IRoutingState router)
        {
            var logger = NLog.LogManager.GetCurrentClassLogger();

            _router = router;

            OnCompomentsRegisted = Observable.Create<Unit>(observer => Scheduler.Default.Schedule(() =>
            {
                logger.Info(string.Format("Starting Compoments Registration on thread {0}.", Thread.CurrentThread));

                eventAggregator.Publish(new OpenNewLifetimeScopeCommand(builder =>
                {
                    builder.RegisterType<WelcomeViewModel>().InstancePerLifetimeScope();
                    builder.RegisterType<Welcome>().As<IViewFor<WelcomeViewModel>>().InstancePerLifetimeScope();

                    builder.RegisterType<NextPage1ViewModel>().InstancePerLifetimeScope();
                    builder.RegisterType<NextPage1>().As<IViewFor<NextPage1ViewModel>>().InstancePerLifetimeScope();
                }));
                observer.OnNext(Unit.Default);
                observer.OnCompleted();
            }));
        }

 public void RaiseCanExecuteChangedShouldBeInvokedOnStateChangedMessage()
 {
     var notifier = new EventAggregator(true);
     bool isInvoked = false;
     var relayCommand = CreateCommand(NodoAction, o => true);
     relayCommand.CanExecuteMode = ExecutionMode.None;
     relayCommand.CanExecuteChanged += (sender, args) =>
     {
         isInvoked = true;
     };
     relayCommand.AddNotifier(notifier);
     notifier.Publish(notifier, StateChangedMessage.Empty);
     isInvoked.ShouldBeTrue();
 }

        public void A_valid_message_invokes_HandlerResultProcessing_when_expected_to() {
            var eventAggregator = new EventAggregator();
            var coroutineHandlerMock = new Mock<IHandleWithCoroutine<object>>();
            var taskHandlerMock = new Mock<IHandleWithTask<object>>();
            var coroutineHandlerProcessed = false;
            var taskHandlerProcessed = false;

            coroutineHandlerMock.Setup(handlerStub => handlerStub.Handle(It.IsAny<object>()))
                                .Returns(() => new List<IResult>());

            taskHandlerMock.Setup(handlerStub => handlerStub.Handle(It.IsAny<object>()))
                           .Returns(() => new Task(() => { }));

            EventAggregator.HandlerResultProcessing = (target, result) => {

                if (target is IHandleWithCoroutine<object>) {
                    coroutineHandlerProcessed = true;
                }
                else if (target is IHandleWithTask<object>) {
                    taskHandlerProcessed = true;
                }
            };

            eventAggregator.Subscribe(coroutineHandlerMock.Object);
            eventAggregator.Subscribe(taskHandlerMock.Object);
            eventAggregator.Publish(new object());

            Assert.True(coroutineHandlerProcessed);
            Assert.True(taskHandlerProcessed);
        }

        public void A_valid_message_is_invoked_on_the_supplied_marshaller() {
            var eventAggregator = new EventAggregator();
            var handlerMock = new Mock<IHandle<object>>();
            var marshallerCalled = false;

            eventAggregator.Subscribe(handlerMock.Object);
            eventAggregator.Publish(new object(), action => marshallerCalled = true);

            Assert.True(marshallerCalled);
        }