C# MemoryHost.MapHubs方法代码示例

        public void AddingToMultipleGroups()
        {
            var host = new MemoryHost();
            host.MapHubs();
            int max = 100;

            var countDown = new CountDown(max);
            var list = Enumerable.Range(0, max).ToList();
            var connection = new Client.Hubs.HubConnection("http://foo");
            var proxy = connection.CreateProxy("MultGroupHub");

            proxy.On<User>("onRoomJoin", user =>
            {
                lock (list)
                {
                    list.Remove(user.Index);
                }

                countDown.Dec();
            });

            connection.Start(host).Wait();

            for (int i = 0; i < max; i++)
            {
                proxy.Invoke("login", new User { Index = i, Name = "tester", Room = "test" + i }).Wait();
            }

            Assert.True(countDown.Wait(TimeSpan.FromSeconds(10)), "Didn't receive " + max + " messages. Got " + (max - countDown.Count) + " missed " + String.Join(",", list.Select(i => i.ToString())));

            connection.Stop();
        }

        public void GenericTaskWithException()
        {
            var host = new MemoryHost();
            host.MapHubs();
            var connection = new Client.Hubs.HubConnection("http://foo/");

            var hub = connection.CreateProxy("demo");

            connection.Start(host).Wait();

            var ex = Assert.Throws<AggregateException>(() => hub.Invoke("GenericTaskWithException").Wait());

            Assert.Equal("Exception of type 'System.Exception' was thrown.", ex.GetBaseException().Message);
        }

        public void GetValueFromServer()
        {
            var host = new MemoryHost();
            host.MapHubs();
            var connection = new Client.Hubs.HubConnection("http://foo/");

            var hub = connection.CreateProxy("demo");

            connection.Start(host).Wait();

            var result = hub.Invoke<int>("GetValue").Result;

            Assert.Equal(10, result);
        }

        public void Overloads()
        {
            var host = new MemoryHost();
            host.MapHubs();
            var connection = new Client.Hubs.HubConnection("http://foo/");

            var hub = connection.CreateProxy("demo");

            connection.Start(host).Wait();

            hub.Invoke("Overload").Wait();
            int n = hub.Invoke<int>("Overload", 1).Result;

            Assert.Equal(1, n);
        }

        public void SettingState()
        {
            var host = new MemoryHost();
            host.MapHubs();
            var connection = new Client.Hubs.HubConnection("http://foo/");

            var hub = connection.CreateProxy("demo");

            hub["name"] = "test";

            connection.Start(host).Wait();

            var result = hub.Invoke<string>("ReadStateValue").Result;

            Assert.Equal("test", result);
        }

        public void ComplexPersonState()
        {
            var host = new MemoryHost();
            host.MapHubs();
            var connection = new Client.Hubs.HubConnection("http://site/");

            var hub = connection.CreateProxy("demo");

            var wh = new ManualResetEvent(false);

            connection.Start(host).Wait();

            var person = new SignalR.Samples.Hubs.DemoHub.DemoHub.Person
            {
                Address = new SignalR.Samples.Hubs.DemoHub.DemoHub.Address
                {
                    Street = "Redmond",
                    Zip = "98052"
                },
                Age = 25,
                Name = "David"
            };

            var person1 = hub.Invoke<SignalR.Samples.Hubs.DemoHub.DemoHub.Person>("ComplexType", person).Result;
            var person2 = hub.GetValue<SignalR.Samples.Hubs.DemoHub.DemoHub.Person>("person");
            JObject obj = ((dynamic)hub).person;
            var person3 = obj.ToObject<SignalR.Samples.Hubs.DemoHub.DemoHub.Person>();

            Assert.NotNull(person1);
            Assert.NotNull(person2);
            Assert.NotNull(person3);
            Assert.Equal("David", person1.Name);
            Assert.Equal("David", person2.Name);
            Assert.Equal("David", person3.Name);
            Assert.Equal(25, person1.Age);
            Assert.Equal(25, person2.Age);
            Assert.Equal(25, person3.Age);
            Assert.Equal("Redmond", person1.Address.Street);
            Assert.Equal("Redmond", person2.Address.Street);
            Assert.Equal("Redmond", person3.Address.Street);
            Assert.Equal("98052", person1.Address.Zip);
            Assert.Equal("98052", person2.Address.Zip);
            Assert.Equal("98052", person3.Address.Zip);

            connection.Stop();
        }

        public void HubNamesAreNotCaseSensitive()
        {
            var host = new MemoryHost();
            host.MapHubs();

            var hubConnection = new HubConnection("http://fake");
            IHubProxy proxy = hubConnection.CreateProxy("chatHub");
            var wh = new ManualResetEvent(false);

            proxy.On("addMessage", data =>
            {
                Assert.Equal("hello", data);
                wh.Set();
            });

            hubConnection.Start(host).Wait();

            proxy.Invoke("Send", "hello").Wait();

            Assert.True(wh.WaitOne(TimeSpan.FromSeconds(5)));
        }

        public void EndToEndTest()
        {
            var host = new MemoryHost();
            host.MapHubs();

            var hubConnection = new HubConnection("http://fake");
            IHubProxy proxy = hubConnection.CreateProxy("ChatHub");
            var called = false;

            proxy.On("addMessage", data =>
            {
                called = true;
                Assert.Equal("hello", data);
            });

            hubConnection.Start(host).Wait();

            proxy.Invoke("Send", "hello").Wait();

            Assert.True(called);
        }

        public void DisconnectFiresForHubsWhenConnectionGoesAway()
        {
            var host = new MemoryHost();
            host.MapHubs();
            host.Configuration.DisconnectTimeout = TimeSpan.Zero;
            host.Configuration.HeartBeatInterval = TimeSpan.FromSeconds(5);
            var connectWh = new ManualResetEventSlim();
            var disconnectWh = new ManualResetEventSlim();
            host.DependencyResolver.Register(typeof(MyHub), () => new MyHub(connectWh, disconnectWh));
            var connection = new Client.Hubs.HubConnection("http://foo/");

            // Maximum wait time for disconnect to fire (3 heart beat intervals)
            var disconnectWait = TimeSpan.FromTicks(host.Configuration.HeartBeatInterval.Ticks * 3);

            connection.Start(host).Wait();

            Assert.True(connectWh.Wait(TimeSpan.FromSeconds(10)), "Connect never fired");

            connection.Stop();

            Assert.True(disconnectWh.Wait(disconnectWait), "Disconnect never fired");
        }

        public void ChangeHubUrl()
        {
            var host = new MemoryHost();
            host.MapHubs("/foo");
            var connection = new Client.Hubs.HubConnection("http://site/foo", useDefaultUrl: false);

            var hub = connection.CreateProxy("demo");

            var wh = new ManualResetEvent(false);

            hub.On("signal", id =>
            {
                Assert.NotNull(id);
                wh.Set();
            });

            connection.Start(host).Wait();

            hub.Invoke("DynamicTask").Wait();

            Assert.True(wh.WaitOne(TimeSpan.FromSeconds(5)));
        }

        public void AuthenticatedAndAuthorizedUserCanInvokeMethodsInHubsAuthorizedWithRoles()
        {
            var host = new MemoryHost();
            host.MapHubs();
            var connection = new Client.Hubs.HubConnection("http://foo/");

            host.User = new GenericPrincipal(new GenericIdentity("test"), new string[] { "Admin" });

            var hub = connection.CreateProxy("AdminAuthHub");
            var wh = new ManualResetEvent(false);
            hub.On<string, string>("invoked", (id, time) =>
            {
                Assert.NotNull(id);
                wh.Set();
            });

            connection.Start(host).Wait();

            hub.Invoke("InvokedFromClient").Wait();

            Assert.True(wh.WaitOne(TimeSpan.FromSeconds(3)));
            connection.Stop();
        }

        public void SendToSelf()
        {
            var host = new MemoryHost();
            host.MapHubs();
            var connection1 = new Client.Hubs.HubConnection("http://foo/");
            var connection2 = new Client.Hubs.HubConnection("http://foo/");

            var wh1 = new ManualResetEventSlim(initialState: false);
            var wh2 = new ManualResetEventSlim(initialState: false);

            var hub1 = connection1.CreateProxy("SendToSome");
            var hub2 = connection2.CreateProxy("SendToSome");

            connection1.Start(host).Wait();
            connection2.Start(host).Wait();

            hub1.On("send", wh1.Set);
            hub2.On("send", wh2.Set);

            hub1.Invoke("SendToSelf").Wait();

            Assert.True(wh1.WaitHandle.WaitOne(TimeSpan.FromSeconds(5)));
            Assert.False(wh2.WaitHandle.WaitOne(TimeSpan.FromSeconds(5)));

            connection1.Stop();
            connection2.Stop();
        }

        public void HubGroupsRejoinWhenRejoiningGroupsOverridden()
        {
            var host = new MemoryHost();
            host.Configuration.KeepAlive = null;
            host.Configuration.ConnectionTimeout = TimeSpan.FromSeconds(1);
            host.Configuration.HeartBeatInterval = TimeSpan.FromSeconds(1);
            host.MapHubs();
            int max = 10;

            var countDown = new CountDownRange<int>(Enumerable.Range(0, max));
            var countDownAfterReconnect = new CountDownRange<int>(Enumerable.Range(max, max));
            var connection = new Client.Hubs.HubConnection("http://foo");
            var proxy = connection.CreateProxy("RejoinMultGroupHub");

            proxy.On<User>("onRoomJoin", u =>
            {
                if (u.Index < max)
                {
                    Assert.True(countDown.Mark(u.Index));
                }
                else
                {
                    Assert.True(countDownAfterReconnect.Mark(u.Index));
                }
            });

            connection.Start(host).Wait();

            var user = new User { Name = "tester" };
            proxy.Invoke("login", user).Wait();

            for (int i = 0; i < max; i++)
            {
                user.Index = i;
                proxy.Invoke("joinRoom", user).Wait();
            }

            // Force Reconnect
            Thread.Sleep(TimeSpan.FromSeconds(3));

            for (int i = max; i < 2 * max; i++)
            {
                user.Index = i;
                proxy.Invoke("joinRoom", user).Wait();
            }

            Assert.True(countDown.Wait(TimeSpan.FromSeconds(3)), "Didn't receive " + max + " messages. Got " + (max - countDown.Count) + " missed " + String.Join(",", countDown.Left.Select(i => i.ToString())));
            Assert.True(countDownAfterReconnect.Wait(TimeSpan.FromSeconds(3)), "Didn't receive " + max + " messages. Got " + (max - countDown.Count) + " missed " + String.Join(",", countDown.Left.Select(i => i.ToString())));

            connection.Stop();
        }

        public void RejoiningGroupsOnlyReceivesGroupsBelongingToHub()
        {
            var host = new MemoryHost();
            var groupsRequestedToBeRejoined = new List<string>();
            var groupsRequestedToBeRejoined2 = new List<string>();
            host.DependencyResolver.Register(typeof(RejoinMultGroupHub), () => new RejoinMultGroupHub(groupsRequestedToBeRejoined));
            host.DependencyResolver.Register(typeof(RejoinMultGroupHub2), () => new RejoinMultGroupHub2(groupsRequestedToBeRejoined2));
            host.Configuration.KeepAlive = null;
            host.Configuration.ConnectionTimeout = TimeSpan.FromSeconds(1);
            host.Configuration.HeartBeatInterval = TimeSpan.FromSeconds(1);
            host.MapHubs();

            var connection = new Client.Hubs.HubConnection("http://foo");
            var proxy = connection.CreateProxy("RejoinMultGroupHub");
            var proxy2 = connection.CreateProxy("RejoinMultGroupHub2");

            connection.Start(host).Wait();

            var user = new User { Name = "tester" };
            proxy.Invoke("login", user).Wait();
            proxy2.Invoke("login", user).Wait();

            // Force Reconnect
            Thread.Sleep(TimeSpan.FromSeconds(3));

            proxy.Invoke("joinRoom", user).Wait();
            proxy2.Invoke("joinRoom", user).Wait();

            Thread.Sleep(TimeSpan.FromSeconds(3));

            Assert.True(groupsRequestedToBeRejoined.Contains("foo"));
            Assert.True(groupsRequestedToBeRejoined.Contains("tester"));
            Assert.False(groupsRequestedToBeRejoined.Contains("foo2"));
            Assert.False(groupsRequestedToBeRejoined.Contains("tester2"));
            Assert.True(groupsRequestedToBeRejoined2.Contains("foo2"));
            Assert.True(groupsRequestedToBeRejoined2.Contains("tester2"));
            Assert.False(groupsRequestedToBeRejoined2.Contains("foo"));
            Assert.False(groupsRequestedToBeRejoined2.Contains("tester"));

            connection.Stop();
        }

        public void UnauthenticatedUserCannotInvokeMethodsWhenAuthenticationRequiredGlobally()
        {
            var host = new MemoryHost();
            host.MapHubs();
            var connection = new Client.Hubs.HubConnection("http://foo/");

            host.HubPipeline.RequireAuthentication();
            host.User = new GenericPrincipal(new GenericIdentity(""), new string[] { });

            var hub = connection.CreateProxy("NoAuthHub");
            var wh = new ManualResetEvent(false);
            hub.On<string, string>("invoked", (id, time) =>
            {
                Assert.NotNull(id);
                wh.Set();
            });

            connection.Start(host).Wait();

            Assert.Throws<AggregateException>(() => hub.Invoke("InvokedFromClient").Wait());

            Assert.False(wh.WaitOne(TimeSpan.FromSeconds(3)));
            connection.Stop();
        }