C# Pubnub.subscribe方法代码示例

        public void Send_to_standIn()
        {
            var cre = PubnubCredentials.LoadFrom("pubnub credentials.txt");
            using(var sut = new PubnubHostTransceiver(cre, "hostchannel"))
            {
                var standIn = new Pubnub(cre.PublishingKey, cre.SubscriptionKey, cre.SecretKey);
                try
                {
                    var standInChannel = Guid.NewGuid().ToString();

                    var are = new AutoResetEvent(false);
                    ReadOnlyCollection<object> result = null;
                    standIn.subscribe(standInChannel, (ReadOnlyCollection<object> _) =>
                                              {
                                                  result = _;
                                                  are.Set();
                                              });

                    var ho = new HostOutput{CorrelationId = Guid.NewGuid(), Data = "hello".Serialize(), Portname = "portname"};
                    sut.SendToStandIn(new Tuple<string, HostOutput>(standInChannel, ho));

                    Assert.IsTrue(are.WaitOne(5000));

                    var hoReceived = Convert.FromBase64String((string)((JValue)result[0]).Value).Deserialize() as HostOutput;
                    Assert.AreEqual(ho.CorrelationId, hoReceived.CorrelationId);
                    Assert.AreEqual(ho.Data, hoReceived.Data);
                    Assert.AreEqual(ho.Portname, hoReceived.Portname);
                }
                finally
                {
                    standIn.subscribe("standIn", _ => {});
                }
            }
        }

        public void ThenPresenceShouldReturnReceivedMessage()
        {
            receivedFlag1 = false;

            Pubnub pubnub = new Pubnub("demo", "demo", "", "", false);
            
            PubnubUnitTest unitTest = new PubnubUnitTest();
            unitTest.TestClassName = "WhenAClientIsPresented";
            unitTest.TestCaseName = "ThenPresenceShouldReturnReceivedMessage";
            pubnub.PubnubUnitTest = unitTest;
            
            string channel = "my/channel";

            pubnub.presence<string>(channel, ThenPresenceShouldReturnMessage);

            //since presence expects from stimulus from sub/unsub...
            pubnub.subscribe<string>(channel, DummyMethodForSubscribe);
            manualEvent1.WaitOne(2000);

            pubnub.unsubscribe<string>(channel, DummyMethodForUnSubscribe);
            manualEvent3.WaitOne(2000);

            manualEvent2.WaitOne(310 * 1000);

            pubnub.presence_unsubscribe<string>(channel, DummyMethodForPreUnSub);
            preUnsubEvent.WaitOne();
            
            Assert.IsTrue(receivedFlag1, "Presence message not received");
        }

        public void ThenSubscribeShouldReturnReceivedMessage()
        {
            receivedMessage = false;
            Pubnub pubnub = new Pubnub("demo","demo","","",false);

            PubnubUnitTest unitTest = new PubnubUnitTest();
            unitTest.TestClassName = "WhenSubscribedToAChannel";
            unitTest.TestCaseName = "ThenSubscribeShouldReturnReceivedMessage";

            pubnub.PubnubUnitTest = unitTest;


            string channel = "my/channel";

            pubnub.subscribe<string>(channel, ReceivedMessageCallbackNoConnect);
            //Thread.Sleep(5000);

            pubnub.publish<string>(channel, "Test for WhenSubscribedToAChannel ThenItShouldReturnReceivedMessage", dummyPublishCallback);
            mePublish.WaitOne(310 * 1000);

            meSubNoConnect.WaitOne(310 * 1000);
            pubnub.unsubscribe<string>(channel, dummyUnsubCallback);
            
            meUnsub.WaitOne(310 * 1000);
            Assert.IsTrue(receivedMessage,"WhenSubscribedToAChannel --> ThenItShouldReturnReceivedMessage Failed");
        }

        public PubnubStandInTransceiver(PubnubCredentials credentials, string hostChannel)
        {
            _transceiver = new Pubnub(credentials.PublishingKey, credentials.SubscriptionKey, credentials.SecretKey);
            _receiverChannel = Guid.NewGuid().ToString();
            _transceiver.subscribe(_receiverChannel, Process_output_from_host);

            _hostChannel = hostChannel;
        }

        public void ThenItShouldReturnReceivedMessage()
        {
            Pubnub pubnub = new Pubnub(
                "demo",
                "demo",
                "",
                false
            );
            string channel = "my/channel";

            pubnub.PropertyChanged += new PropertyChangedEventHandler(Pubnub_PropertyChanged);

            pubnub.subscribe(channel);
        }

        public void ThenSubscribeShouldReturnReceivedMessage()
        {
            receivedMessage = false;
            Pubnub pubnub = new Pubnub("demo","demo","","",false);

            string channel = "test";

            EnqueueCallback(() => pubnub.subscribe<string>(channel, ReceivedMessageCallback));
            EnqueueCallback(() => pubnub.publish<string>(channel, "Test for WhenSubscribedToAChannel ThenItShouldReturnReceivedMessage", dummyPublishCallback));
            EnqueueConditional(() => isPublished);
            EnqueueConditional(() => isReceived);
            EnqueueCallback(() => Assert.IsTrue(receivedMessage, "WhenSubscribedToAChannel --> ThenItShouldReturnReceivedMessage Failed"));

            EnqueueTestComplete();
        }

        public void ThenItShouldReturnReceivedMessage()
        {
            Pubnub pubnub = new Pubnub(
                   "demo",
                   "demo",
                   "",
                   "",
                   false);

            //string channel = "my ~`[email protected]#$%^&*()+=[]\\{}|;':\",./<>?channel";
            string channel = "my_channel";

            pubnub.subscribe(channel, ThenDoCallback);
            manualEvent.WaitOne(10000, false);
            Assert.IsTrue(receivedMessage);
        }

        public void ThenSubscribeShouldReturnReceivedMessage()
        {
            receivedMessage = false;
            Pubnub pubnub = new Pubnub("demo","demo","","",false);

            string channel = "my/channel";

            pubnub.subscribe<string>(channel, ReceivedMessageCallback);
            Thread.Sleep(5000);

            pubnub.publish<string>(channel, "Test for WhenSubscribedToAChannel ThenItShouldReturnReceivedMessage", dummyPublishCallback);
            manualEvent2.WaitOne(310 * 1000);

            manualEvent1.WaitOne(310*1000);
            Assert.IsTrue(receivedMessage,"WhenSubscribedToAChannel --> ThenItShouldReturnReceivedMessage Failed");
        }

        public void ThenPresenceShouldReturnReceivedMessage()
        {
            receivedFlag1 = false;

            Pubnub pubnub = new Pubnub("demo", "demo", "", "", false);
            string channel = "my/channel";

            EnqueueCallback(() => pubnub.presence<string>(channel, ThenPresenceShouldReturnMessage));
            EnqueueCallback(() => pubnub.subscribe<string>(channel, DummyMethodForSubscribe));
            EnqueueConditional(() => isSubscribed);
            EnqueueCallback(() => pubnub.unsubscribe<string>(channel, DummyMethodForUnSubscribe));
            EnqueueConditional(() => isUnSubscribed);
            EnqueueConditional(() => isPresenceReturnMessage);
            EnqueueCallback(() => Assert.IsTrue(receivedFlag1, "Presence message not received"));

            EnqueueTestComplete();
        }

        public void Run()
        {
            var are = new AutoResetEvent(false);

            var pubnubServer = new Pubnub("demo", "demo");
            pubnubServer.subscribe("testchannel", (ReadOnlyCollection<object> _) =>
                                                      {
                                                          var v = _[0] as JValue;
                                                          var a = Convert.FromBase64String((string)v.Value);
                                                          Console.WriteLine("received: {0}", a);
                                                          are.Set();
                                                      });

            var pubnubClient = new Pubnub("demo", "demo");
            pubnubClient.publish("testchannel", new byte[]{1,2,3}, _ => Console.WriteLine("published"));

            Assert.IsTrue(are.WaitOne(5000));
        }

        public void ThenPresenceShouldReturnReceivedMessage()
        {
            receivedFlag1 = false;

            Pubnub pubnub = new Pubnub("demo", "demo", "", "", false);
            string channel = "my/channel";

            pubnub.presence<string>(channel, ThenPresenceShouldReturnMessage);

            //since presence expects from stimulus from sub/unsub...
            pubnub.subscribe<string>(channel, DummyMethodForSubscribe);
            manualEvent1.WaitOne(2000);

            pubnub.unsubscribe<string>(channel, DummyMethodForUnSubscribe);
            manualEvent3.WaitOne(2000);

            manualEvent2.WaitOne(310 * 1000);
            Assert.IsTrue(receivedFlag1, "Presence message not received");
        }

        public void ThenItShouldReturnReceivedMessage()
        {
            receivedFlag = false;

            Pubnub pubnub = new Pubnub(
                "demo",
                "demo",
                "",
                "",
                false
            );
            string channel = "hello_world";
            pubnub.presence<string>(channel, ThenItShouldReturnPresenceMessage);

            //since presence expects from stimulus from sub/unsub...
            pubnub.subscribe<string>(channel, DummyMethodForSubscribe);
            pubnub.unsubscribe<string>(channel, DummyMethodForSubscribe);

            manualEvent.WaitOne();
            Assert.IsTrue(receivedFlag, "Presence message not received");
        }

        public void Send_to_host()
        {
            var cre = PubnubCredentials.LoadFrom("pubnub credentials.txt");

            var host = new Pubnub(cre.PublishingKey, cre.SubscriptionKey);
            try
            {
                var are = new AutoResetEvent(false);
                ReadOnlyCollection<object> result = null;
                host.subscribe("hostchannel", (ReadOnlyCollection<object> _) =>
                {
                    result = _;
                    are.Set();
                });

                using (var sut = new PubnubStandInTransceiver(cre, "hostchannel"))
                {
                    var hi = new HostInput
                                 {
                                     CorrelationId = Guid.NewGuid(),
                                     Data = "hello".Serialize(),
                                     Portname = "portname",
                                     StandInEndpointAddress = "endpoint"
                                 };
                    sut.SendToHost(hi);

                    Assert.IsTrue(are.WaitOne(5000));

                    var hiReceived = Convert.FromBase64String((string) ((JValue) result[0]).Value).Deserialize() as HostInput;
                    Assert.AreEqual(hi.CorrelationId, hiReceived.CorrelationId);
                    Assert.AreEqual(hi.Data, hiReceived.Data);
                    Assert.AreEqual(hi.Portname, hiReceived.Portname);
                    Assert.AreEqual(hi.StandInEndpointAddress, hiReceived.StandInEndpointAddress);
                }
            }
            finally
            {
                host.unsubscribe("hostchannel", _ => {});
            }
        }

        public void ThenItShouldReturnReceivedMessage()
        {
            string status = "";
            Pubnub pubnub = new Pubnub(
                   "demo",
                   "demo",
                   "",
                   false);
            string channel = "my/channel";

            pubnub.PropertyChanged += delegate(object sender, PropertyChangedEventArgs e)
            {
                if (e.PropertyName == "ReturnMessage")
                {
                    Dictionary<string, object> _message = (Dictionary<string, object>)(((Pubnub)sender).ReturnMessage);
                    Console.WriteLine("Received Message -> '" + _message["text"] + "'");
                    status = _message["text"].ToString();
                    Assert.AreEqual("assert", status);
                }
            };
            pubnub.subscribe(channel);
        }

        public void ThenSubscribeShouldReturnConnectStatus()
        {
            receivedMessage = false;
            Pubnub pubnub = new Pubnub("demo", "demo", "", "", false);

            PubnubUnitTest unitTest = new PubnubUnitTest();
            unitTest.TestClassName = "WhenSubscribedToAChannel";
            unitTest.TestCaseName = "ThenSubscribeShouldReturnConnectStatus";

            pubnub.PubnubUnitTest = unitTest;


            string channel = "my/channel";

            pubnub.subscribe<string>(channel, ReceivedMessageCallbackYesConnect, ConnectStatusCallback);
            meSubYesConnect.WaitOne(310 * 1000);

            pubnub.unsubscribe<string>(channel, dummyUnsubCallback);
            meUnsub.WaitOne(310 * 1000);

            Assert.IsTrue(receivedMessage, "WhenSubscribedToAChannel --> ThenSubscribeShouldReturnConnectStatus Failed");
        }