C# MessageBus.Unregister方法代码示例

        public void TestUnregisterOneAction()
        {
            const string testContentA1 = "abcd";
            const string testContentA2 = "efgh";

            Reset();
            IMessageBus messageBus = new MessageBus();

            Action<TestMessageA> actionA1 = m => ReceivedContentStringA1 = m.Content;

            messageBus.Register(this, TestConstants.MyContentToken, actionA1);

            Assert.AreEqual(null, ReceivedContentStringA1);

            messageBus.Send(new TestMessageA
            {
                Content = testContentA1
            }, TestConstants.MyContentToken);

            Assert.AreEqual(testContentA1, ReceivedContentStringA1);

            messageBus.Unregister(this, TestConstants.MyContentToken, actionA1);

            messageBus.Send(new TestMessageA
            {
                Content = testContentA2
            }, TestConstants.MyContentToken);

            Assert.AreNotEqual(testContentA2, ReceivedContentStringA1);
        }

        public void InnerListHasOneItemAfterUnregisterIsCalledForSpecificActionWhereTwoActionsRegisteredForOneToken()
        {
            const string testContent1 = "efgh";
            const string testContent2 = "mnop";
            const int token = 4567;

            Reset();
            IMessageBus messageBus = new MessageBus();

            Action<string> action1 = m => ReceivedContentStringA = m;
            Action<string> action2 = m => ReceivedContentStringB = m;

            messageBus.Register(this, token, action1);
            messageBus.Register(this, token, action2);

            messageBus.Send(testContent1, token);

            Assert.AreEqual(testContent1, ReceivedContentStringA);
            Assert.AreEqual(testContent1, ReceivedContentStringB);

            messageBus.Unregister(this, token, action2); // only unregister action2. Leave action1.

            var type = typeof(MessageBus);

            // _commandCollection is an instance, private member
            BindingFlags flags = BindingFlags.Instance | BindingFlags.NonPublic;

            // Retrieve a FieldInfo instance corresponding to the field
            FieldInfo field = type.GetField("_recipientsStrictAction", flags);

            var innerRecipientsDictionary = field.GetValue(messageBus) as Dictionary<Type, List<MessageBus.WeakActionAndToken>>;

            messageBus.Send(testContent2, token);

            Assert.AreEqual(testContent2, ReceivedContentStringA);
            Assert.AreEqual(testContent1, ReceivedContentStringB);
            Assert.IsTrue(innerRecipientsDictionary.Count == 1);
        }

        public void TestUnRegisterObjectOnlyOverloadWithOneHandler()
        {
            const string testContentString = "abcd";
            const string testContentStringAfterUnregister = "efgh";

            Reset();
            IMessageBus messageBus = new MessageBus();

            messageBus.Register<string>(this, TestConstants.MyStringToken, m => ReceivedContentStringA1 = m);

            Assert.AreEqual(null, ReceivedContentStringA1);

            messageBus.Send(testContentString, TestConstants.MyStringToken);

            Assert.AreEqual(testContentString, ReceivedContentStringA1);

            messageBus.Unregister<string>(this); // Use overload which just uses object

            messageBus.Send(testContentStringAfterUnregister, TestConstants.MyStringToken);

            Assert.AreNotEqual(testContentStringAfterUnregister, ReceivedContentStringA1);
        }

        public void TestUnRegisterObjectOnlyOverloadWithMoreThanOneHandler()
        {
            const string testContentString1 = "abcd1";
            const string testContentString2 = "abcd2";
            const string testContentStringAfterUnregister = "efgh";

            Action<string> action1 = m => ReceivedContentStringA = m;
            Action<string> action2 = m => ReceivedContentStringA1 = m;
            Action<string> action3 = m => ReceivedContentStringB = m;

            Reset();
            IMessageBus messageBus = new MessageBus();

            messageBus.Register<string>(this, TestConstants.MyStringToken, action1);
            messageBus.Register<string>(this, TestConstants.MyStringToken, action2);
            messageBus.Register<string>(this, TestConstants.MyContentToken, action3);

            Assert.AreEqual(null, ReceivedContentStringA);
            Assert.AreEqual(null, ReceivedContentStringA1);
            Assert.AreEqual(null, ReceivedContentStringB);

            messageBus.Send(testContentString1, TestConstants.MyStringToken);
            messageBus.Send(testContentString2, TestConstants.MyContentToken);

            Assert.AreEqual(testContentString1, ReceivedContentStringA);
            Assert.AreEqual(testContentString1, ReceivedContentStringA1);
            Assert.AreEqual(testContentString2, ReceivedContentStringB);

            messageBus.Unregister<string>(this); // Use overload which just uses object

            messageBus.Send(testContentStringAfterUnregister, TestConstants.MyStringToken);
            messageBus.Send(testContentStringAfterUnregister, TestConstants.MyContentToken);

            Assert.AreNotEqual(testContentStringAfterUnregister, ReceivedContentStringA1);
            Assert.AreNotEqual(testContentStringAfterUnregister, ReceivedContentStringB);
        }

        public void TestRegisterUnregisterWithToken()
        {
            const string testContent1 = "abcd";
            const string testContent2 = "efgh";
            const string testContent3 = "ijkl";
            const int token1 = 1234;
            const int token2 = 4567;

            Reset();
            IMessageBus messageBus = new MessageBus();

            messageBus.Register<string>(this, token1, m => ReceivedContentStringA1 = m);
            messageBus.Register<string>(this, token2, m => ReceivedContentStringA = m);

            Assert.AreEqual(null, ReceivedContentStringA1);
            Assert.AreEqual(null, ReceivedContentStringA);

            messageBus.Send(testContent1, token1);

            Assert.AreEqual(testContent1, ReceivedContentStringA1);
            Assert.AreEqual(null, ReceivedContentStringA);

            messageBus.Send(testContent2, token2);

            Assert.AreEqual(testContent1, ReceivedContentStringA1);
            Assert.AreEqual(testContent2, ReceivedContentStringA);

            messageBus.Unregister<string>(this, token1);
            messageBus.Send(testContent3, token1);

            Assert.AreEqual(testContent1, ReceivedContentStringA1);
            Assert.AreEqual(testContent2, ReceivedContentStringA);
        }

        public void TestRegisterUnregisterOneActionWithToken()
        {
            const string testContent1 = "abcd";
            const string testContent2 = "efgh";
            const string testContent3 = "ijkl";
            const string testContent4 = "mnop";
            const int token1 = 1234;
            const int token2 = 4567;

            Reset();
            IMessageBus messageBus = new MessageBus();

            Action<string> action1 = m => ReceivedContentStringA1 = m;
            Action<string> action2 = m => ReceivedContentStringA = m;
            Action<string> action3 = m => ReceivedContentStringB = m;

            messageBus.Register(this, token1, action1);
            messageBus.Register(this, token2, action2);
            messageBus.Register(this, token2, action3);

            messageBus.Send(testContent1, token1);
            messageBus.Send(testContent2, token2);

            Assert.AreEqual(testContent1, ReceivedContentStringA1);
            Assert.AreEqual(testContent2, ReceivedContentStringA);
            Assert.AreEqual(testContent2, ReceivedContentStringB);

            messageBus.Unregister(this, token2, action3);
            messageBus.Send(testContent3, token1);
            messageBus.Send(testContent4, token2);

            Assert.AreEqual(testContent3, ReceivedContentStringA1);
            Assert.AreEqual(testContent4, ReceivedContentStringA);
            Assert.AreEqual(testContent2, ReceivedContentStringB);
        }

        public void InnerListIsEmptyAfterUnregisterIsCalledWhereTwoActionsRegisteredForOneToken()
        {
            const int token2 = 4567;

            Reset();
            IMessageBus messageBus = new MessageBus();

            Action<string> action2 = m => ReceivedContentStringA = m;
            Action<string> action3 = m => ReceivedContentStringB = m;

            messageBus.Register(this, token2, action2);
            messageBus.Register(this, token2, action3);

            //  Only unregister token2 and don't specify an action
            messageBus.Unregister<string>(this, token2);

            var type = typeof(MessageBus);

            // _commandCollection is an instance, private member
            BindingFlags flags = BindingFlags.Instance | BindingFlags.NonPublic;

            // Retrieve a FieldInfo instance corresponding to the field
            FieldInfo field = type.GetField("_recipientsStrictAction", flags);

            var innerRecipientsDictionary = field.GetValue(messageBus) as Dictionary<Type, List<MessageBus.WeakActionAndToken>>;

            Assert.IsFalse(innerRecipientsDictionary.Any());
        }