C# Messenger.Register方法代码示例

        public void MessageWithoutParameterIsReceived()
        {
            Messenger target = new Messenger();

            bool received1 = false;
            bool received2 = false;

            target.Register("MESSAGE", (Action)(() => received1 = true));
            target.Register("MESSAGE", (Action)(() => received2 = true));

            target.NotifyColleagues("MESSAGE");

            Assert.IsTrue(received1);
            Assert.IsTrue(received2);
        }

        public void FlyoutStaysOpenIfWanted()
        {
            // Arrange
            var currentProject = new ProjectViewModel( new Project { Id = 123 } );
            var messenger = new Messenger();
            var todoRepoMock = new Mock<ITodoRepository>();

            bool messageReceived = false;
            messenger.Register<FlyoutMessage>( this, msg => { if( msg.FlyoutName == FlyoutMessage.AddEntryFlyoutName ) messageReceived = true; } );

            var vm = new AddEntryViewModel( Enumerable.Empty<TagViewModel>(), currentProject, todoRepoMock.Object, messenger )
            {
                Summary = "summary"
            };

            // Act
            vm.StayOpen = true;
            vm.AddCommand.Execute( null );
            bool stay = messageReceived;

            vm.Summary = "summary";
            vm.StayOpen = false;
            vm.AddCommand.Execute( null );
            bool dontStay = messageReceived;

            // Assert
            Assert.IsFalse( stay );
            Assert.IsTrue( dontStay );
        }

        public void AddUsesCorrectValues()
        {
            // Arrange
            var tags = new[]
            {
                new TagViewModel( new Tag {Id = 1, Name = "Tag1"} ),
                new TagViewModel( new Tag {Id = 2, Name = "Tag2"} )
            };

            var currentProject = new ProjectViewModel( new Project { Id = 123 } );

            var messenger = new Messenger();
            bool addMessageReceived = false;
            messenger.Register<EntryAddedMessage>( this, msg => addMessageReceived = true );

            var todoRepoMock = new Mock<ITodoRepository>();
            todoRepoMock.Setup( x => x.Add( It.Is<Todo>( t => t.Summary.Equals( "summary" ) && t.Details.Equals( "details" ) && t.Project.Id == 123 ) ) ).Verifiable();
            todoRepoMock.Setup( x => x.Update( It.Is<Todo>( t => t.Tags.First().Id == 2 ) ) ).Verifiable();

            var vm = new AddEntryViewModel( tags, currentProject, todoRepoMock.Object, messenger )
            {
                Summary = "summary",
                Details = "details"
            };

            // Act
            vm.Tags[1].IsSelected = true;
            vm.AddCommand.Execute( null );

            // Assert
            todoRepoMock.VerifyAll();
            Assert.IsTrue( addMessageReceived );
        }

        public void ColleaguesAreNotifiedInRegistrationOrder()
        {
            Messenger target = new Messenger();

            int notificationCounter = 0;
            int notified1 = 0;
            int notified2 = 0;

            target.Register("MESSAGE", (Action)(() => notified1 = ++notificationCounter));
            target.Register("MESSAGE", (Action)(() => notified2 = ++notificationCounter));

            target.NotifyColleagues("MESSAGE");

            Assert.AreEqual(1, notified1 );
            Assert.AreEqual(2, notified2);
        }

        private void Control_Loaded(object sender, System.Windows.RoutedEventArgs e)
        {
            var messenger = new Messenger();

            messenger.Register<UpdateHeaderMessage>(this, m => UpdateHeader(m));

            DataContext = new ControlViewModel(messenger);
        }

        public void DeleteCommandRaisesAddNewCmdApplicationConfigurationEvent(IFixture fixture)
        {
            var messenger = new Messenger();
            var isInvoked = false;
            messenger.Register(this, (DeleteCmdApplicationConfigurationEvent message) =>
            {
                isInvoked = true;
                Assert.Equal(new DeleteCmdApplicationConfigurationEvent(), message);
            });

            var sut = CreateMainViewModel(fixture, messenger);
            sut.DeleteCommand.Execute(new object());
            Assert.True(isInvoked);
        }

        public void MessageWithParameterIsReceived()
        {
            Messenger target = new Messenger();

            bool received = false;

            string paramValue = "whatever";

            target.Register("MESSAGE", (Action<string>)(param => received = (param == paramValue)));

            target.NotifyColleagues("MESSAGE", paramValue);

            Assert.IsTrue(received);
        }

        public void TestMultipleMessengerInstances()
        {
            var messenger1 = new Messenger();
            var messenger2 = new Messenger();

            var recipient11 = new TestRecipient1();
            var recipient12 = new TestRecipient1();
            var recipient21 = new TestRecipient2();
            var recipient22 = new TestRecipient2();

            messenger1.Register<string>(recipient11, recipient11.ReceiveMessage);
            messenger2.Register<string>(recipient12, recipient12.ReceiveMessage);
            messenger1.Register<string>(recipient21, recipient21.ReceiveMessage);
            messenger2.Register<string>(recipient22, recipient22.ReceiveMessage);

            const string TestContent1 = "abcd";
            const string TestContent2 = "efgh";

            Assert.AreEqual(null, recipient11.ReceivedContentString);
            Assert.AreEqual(null, recipient12.ReceivedContentString);
            Assert.AreEqual(null, recipient21.ReceivedContentString);
            Assert.AreEqual(null, recipient22.ReceivedContentString);

            messenger1.Send(TestContent1);

            Assert.AreEqual(TestContent1, recipient11.ReceivedContentString);
            Assert.AreEqual(null, recipient12.ReceivedContentString);
            Assert.AreEqual(TestContent1, recipient21.ReceivedContentString);
            Assert.AreEqual(null, recipient22.ReceivedContentString);

            messenger2.Send(TestContent2);

            Assert.AreEqual(TestContent1, recipient11.ReceivedContentString);
            Assert.AreEqual(TestContent2, recipient12.ReceivedContentString);
            Assert.AreEqual(TestContent1, recipient21.ReceivedContentString);
            Assert.AreEqual(TestContent2, recipient22.ReceivedContentString);
        }

        public void TestMultipleMessageTypes()
        {
            var messenger = new Messenger();
            var recipient = new OldTestRecipient();

            messenger.Register(recipient, typeof(OldTestMessage));
            messenger.Register(recipient, typeof(GenericMessage<InvalidOperationException>));
            messenger.Register(recipient, typeof(GenericMessage<MissingMethodException>));

            Assert.IsNull(recipient.Content);
            Assert.IsNull(recipient.ObjectContent1);
            Assert.IsNull(recipient.ObjectContent2);

            var testObject1 = new InvalidOperationException();
            var genericMessage = new GenericMessage<InvalidOperationException>(this, testObject1);
            messenger.Broadcast(genericMessage);
            Assert.AreEqual(this, recipient.Sender);
            Assert.IsNull(recipient.Content);
            Assert.AreEqual(testObject1, recipient.ObjectContent1);
            Assert.IsNull(recipient.ObjectContent2);

            var testObject2 = new MissingMethodException();
            var genericMessage2 = new GenericMessage<MissingMethodException>(this, testObject2);
            messenger.Broadcast(genericMessage2);
            Assert.AreEqual(this, recipient.Sender);
            Assert.IsNull(recipient.Content);
            Assert.AreEqual(testObject1, recipient.ObjectContent1);
            Assert.AreEqual(testObject2, recipient.ObjectContent2);

            const string TestString = "Hello world";
            var message = new OldTestMessage(this, TestString);
            messenger.Broadcast(message);
            Assert.AreEqual(this, recipient.Sender);
            Assert.AreEqual(TestString, recipient.Content);
            Assert.AreEqual(testObject1, recipient.ObjectContent1);
            Assert.AreEqual(testObject2, recipient.ObjectContent2);
        }

        public void TestInstanceCreation()
        {
            const string TestContent = "abcd";

            Reset();
            var messenger = new Messenger();

            messenger.Register<TestMessage>(this, m => StringContent = m.Content);

            Assert.AreEqual(null, StringContent);

            messenger.Send(new TestMessage
            {
                Content = TestContent
            });

            Assert.AreEqual(TestContent, StringContent);
        }

        public void TestPropertyChangedSendWithCustomMessenger()
        {
            var receivedDateTime1 = DateTime.MinValue;
            var receivedDateTime2 = DateTime.MinValue;

            var messenger = new Messenger();

            messenger.Register<PropertyChangedMessage<DateTime>>(this, m => receivedDateTime1 = m.NewValue);
            Messenger.Default.Register<PropertyChangedMessage<DateTime>>(this, m => receivedDateTime2 = m.NewValue);

            var vm = new TestViewModel(messenger);

            var now = DateTime.Now;
            vm.LastChanged1 = now;
            Assert.AreEqual(now, vm.LastChanged1);
            Assert.AreEqual(now, receivedDateTime1);
            Assert.AreEqual(DateTime.MinValue, receivedDateTime2);
        }

        public void PropertyChangedTestBroadcastApplicationMessenger()
        {
            _receivedDateTime = DateTime.MinValue;

            var messenger = new Messenger();

            var recipient1 = new OldTestRecipient();
            var recipient2 = new OldTestRecipient();
            messenger.Register(recipient1, typeof(PropertyChangedMessage<DateTime>));
            Messenger.Default.Register(recipient2, typeof(PropertyChangedMessage<DateTime>));

            var vm = new OldTestViewModel(messenger);
            vm.PropertyChanged += VMPropertyChanged;

            Assert.AreEqual(_receivedDateTime, DateTime.MinValue);

            var now = DateTime.Now;
            vm.LastChanged2 = now;
            Assert.AreEqual(now, vm.LastChanged2);
            Assert.AreEqual(_receivedDateTime, vm.LastChanged2);
            Assert.AreEqual(now, recipient1.DateTimeContent);
            Assert.AreEqual(DateTime.MinValue, recipient2.DateTimeContent);
        }

        public void TestMultipleRecipients()
        {
            var messenger = new Messenger();
            var recipient1 = new OldTestRecipient();
            var recipient2 = new OldTestRecipient();
            var recipient3 = new OldTestRecipient();

            messenger.Register(recipient1, typeof(OldTestMessage));
            messenger.Register(recipient2, typeof(OldTestMessage));
            messenger.Register(recipient3, typeof(OldTestMessage));

            Assert.IsNull(recipient1.Sender);
            Assert.IsNull(recipient1.Content);
            Assert.IsNull(recipient2.Content);
            Assert.IsNull(recipient2.Sender);
            Assert.IsNull(recipient3.Content);
            Assert.IsNull(recipient3.Sender);

            const string TestString = "Hello world";
            var message = new OldTestMessage(this, TestString);
            messenger.Broadcast(message);

            Assert.AreEqual(TestString, recipient1.Content);
            Assert.AreEqual(this, recipient1.Sender);
            Assert.AreEqual(TestString, recipient2.Content);
            Assert.AreEqual(this, recipient2.Sender);
            Assert.AreEqual(TestString, recipient3.Content);
            Assert.AreEqual(this, recipient3.Sender);
        }

 /// <summary>
 /// Messenger にアクションを登録します。
 /// </summary>
 /// <param name="recipient">メッセージを受け取るオブジェクト を指定します。</param>
 /// <param name="messenger">メッセージを管理するメッセンジャーオブジェクト を指定します。</param>
 public void Register(FrameworkElement recipient, Messenger messenger)
 {
     messenger.Register<WarningMessage>(recipient, ShowMessage);
 }

        public void StaticCallbackMethodIsInvoked()
        {
            Messenger target = new Messenger();

            _wasStaticCallbackMethodInvoked = false;

            target.Register("MESSAGE", (Action)StaticCallbackMethod);

            target.NotifyColleagues("MESSAGE");

            Assert.IsTrue(_wasStaticCallbackMethodInvoked);
        }