コード例 #1
0
        public void InvokeWithStateCopiesStateToHubProxy()
        {
            var hubResult = new HubResult
            {
                State = new Dictionary<string, JToken>
                {
                    { "state", JToken.FromObject(1) }
                }
            };

            var connection = new Mock<IHubConnection>();
            connection.Setup(m => m.RegisterCallback(It.IsAny<Action<HubResult>>()))
                      .Callback<Action<HubResult>>(callback =>
                      {
                          callback(hubResult);
                      });

            connection.Setup(m => m.Send(It.IsAny<string>()))
                      .Returns(TaskAsyncHelper.Empty);

            connection.SetupGet(x => x.JsonSerializer).Returns(new JsonSerializer());

            var hubProxy = new HubProxy(connection.Object, "foo");

            hubProxy.Invoke("Anything").Wait();

            Assert.Equal(1, hubProxy["state"]);
        }
コード例 #2
0
ファイル: ClientHubProvider.cs プロジェクト: Veggie13/Genesis
 private void Disconnect()
 {
     _hub.DisconnectHub();
     _app.AppID = 0;
     _hub = null;
     ChannelServices.UnregisterChannel(_chan);
     _app = null;
 }
コード例 #3
0
ファイル: HubConnection.cs プロジェクト: JamesTryand/SignalR
 public IHubProxy CreateProxy(string hub)
 {
     HubProxy hubProxy;
     if (!_hubs.TryGetValue(hub, out hubProxy)) {
         hubProxy = new HubProxy(this, hub);
         _hubs[hub] = hubProxy;
     }
     return hubProxy;
 }
コード例 #4
0
		public IHubProxy CreateProxy(string hubName)
		{
			HubProxy _hubProxy;
			if (!m_hubs.TryGetValue(hubName, out _hubProxy))
			{
				_hubProxy = new HubProxy(this, hubName);
				m_hubs[hubName] = _hubProxy;
			}
			return _hubProxy;
		}
コード例 #5
0
ファイル: HubProxyTest.cs プロジェクト: ninjaAB/SignalR
        public void InvokeEventRaisesEvent()
        {
            var connection = new Mock<SignalR.Client.IConnection>();
            var hubProxy = new HubProxy(connection.Object, "foo");
            bool eventRaised = false;

            hubProxy.On("foo", () =>
            {
                eventRaised = true;
            });

            hubProxy.InvokeEvent("foo", new object[] { });
            Assert.True(eventRaised);
        }
コード例 #6
0
ファイル: ClientHubProvider.cs プロジェクト: Veggie13/Genesis
        public bool Initialize(IGenesisApplication app)
        {
            if (_hub != null)
                return false;

            ChannelServices.RegisterChannel(_chan, false);
            Hub mainHub = (Hub)Activator.GetObject(typeof(Hub), _url);
            _hub = new HubProxy(mainHub);
            _hub.RegisterApplication(app);
            mainHub.AboutToDie += new Hub.DeathBedEvent(OnDeathBed);
            _app = app;

            return true;
        }
コード例 #7
0
ファイル: HubProxyTest.cs プロジェクト: ninjaAB/SignalR
        public void InvokeEventRaisesEventWithData()
        {
            var connection = new Mock<SignalR.Client.IConnection>();
            var hubProxy = new HubProxy(connection.Object, "foo");
            bool eventRaised = false;

            hubProxy.On<int>("foo", (i) =>
            {
                eventRaised = true;
                Assert.Equal(1, i);
            });

            hubProxy.InvokeEvent("foo", new object[] { 1 });
            Assert.True(eventRaised);
        }
コード例 #8
0
ファイル: HubConnection.cs プロジェクト: Avatarchik/uSignalR
        /// <summary>
        ///     Creates an <see cref="IHubProxy" /> for the hub with the specified name.
        /// </summary>
        /// <param name="hubName">The name of the hub.</param>
        /// <returns>A <see cref="IHubProxy" /></returns>
        public IHubProxy CreateProxy(string hubName)
        {
            if (State != ConnectionState.Disconnected)
                throw new InvalidOperationException("A HubProxy cannot be added after the connection has been started.");

            HubProxy hubProxy;

            if (_hubs.TryGetValue(hubName, out hubProxy))
                return hubProxy;

            hubProxy = new HubProxy(this, hubName);
            _hubs[hubName] = hubProxy;

            return hubProxy;
        }
コード例 #9
0
ファイル: HubProxyFacts.cs プロジェクト: nonintanon/SignalR
        public void InvokeWithErrorInHubResultReturnsFaultedTask()
        {
            var result = new HubResult<object>
            {
                Error = "This in an error"
            };

            var connection = new Mock<SignalR.Client.IConnection>();
            connection.Setup(m => m.Send<HubResult<object>>(It.IsAny<string>()))
                      .Returns(TaskAsyncHelper.FromResult(result));

            var hubProxy = new HubProxy(connection.Object, "foo");

            AssertAggregateException(() => hubProxy.Invoke("Invoke").Wait(),
                                     "This in an error");
        }
コード例 #10
0
ファイル: HubProxyTest.cs プロジェクト: ninjaAB/SignalR
        public void InvokeReturnsHubsResult()
        {
            var hubResult = new HubResult<object>
            {
                Result = "Something"
            };

            var connection = new Mock<SignalR.Client.IConnection>();
            connection.Setup(m => m.Send<HubResult<object>>(It.IsAny<string>()))
                      .Returns(TaskAsyncHelper.FromResult(hubResult));

            var hubProxy = new HubProxy(connection.Object, "foo");

            var result = hubProxy.Invoke<object>("Anything").Result;

            Assert.Equal(result, "Something");
        }
コード例 #11
0
        protected FixtureBase()
        {
            var hubConnectionMock = new Mock<IHubConnection>();
            hubConnectionMock.SetupGet(m => m.JsonSerializer).Returns(new JsonSerializer());

            _hubProxy = new HubProxy(hubConnectionMock.Object, "whatEver");
            HubProxyMock = new Mock<MockedHubProxy>(_hubProxy);
            HubProxyMock.SetupGet(m => m.JsonSerializer).Returns(_hubProxy.JsonSerializer);
            HubProxyMock.Setup(m => m.Subscribe(It.IsAny<string>()))
                .Returns((string eventName) => _hubProxy.Subscribe(eventName));

            HubProxyMock.Setup(m => m.InvokeEvent(It.IsAny<Expression<Action<IClientContract>>>()))
                .Callback<Expression<Action<IClientContract>>>(call =>
                {
                    var invocation = call.GetActionDetails();
                    _hubProxy.InvokeEvent(invocation.MethodName,
                        invocation.Parameters.Select(JToken.FromObject).ToList());
                });
        }
コード例 #12
0
        public void InvokeWithStateCopiesStateToHubProxy()
        {
            var result = new HubResult<object>
            {
                State = new Dictionary<string, object>
                {
                    { "state", 1 }
                }
            };

            var connection = new Mock<SignalR.Client.IConnection>();
            connection.Setup(m => m.Send<HubResult<object>>(It.IsAny<string>()))
                      .Returns(TaskAsyncHelper.FromResult(result));

            var hubProxy = new HubProxy(connection.Object, "foo");

            hubProxy.Invoke("Anything").Wait();

            Assert.Equal(1, hubProxy["state"]);
        }
コード例 #13
0
ファイル: HubProxyFacts.cs プロジェクト: stirno/SignalR
        public void InvokeReturnsHubsResult()
        {
            var hubResult = new HubResult
            {
                Result = "Something"
            };

            var connection = new Mock<SignalR.Client.Hubs.IHubConnection>();
            connection.Setup(m => m.RegisterCallback(It.IsAny<Action<HubResult>>()))
                      .Callback<Action<HubResult>>(callback =>
                      {
                          callback(hubResult);
                      });

            connection.Setup(m => m.Send(It.IsAny<string>()))
                      .Returns(TaskAsyncHelper.Empty);

            var hubProxy = new HubProxy(connection.Object, "foo");

            var result = hubProxy.Invoke<object>("Anything").Result;

            Assert.Equal(result, "Something");
        }
コード例 #14
0
        public void InvokeWithErrorInHubResultReturnsFaultedTask()
        {
            var hubResult = new HubResult
            {
                Error = "This in an error"
            };

            var connection = new Mock<IHubConnection>();
            connection.Setup(m => m.RegisterCallback(It.IsAny<Action<HubResult>>()))
                      .Callback<Action<HubResult>>(callback =>
                      {
                          callback(hubResult);
                      });

            connection.Setup(m => m.Send(It.IsAny<string>()))
                      .Returns(TaskAsyncHelper.Empty);

            connection.SetupGet(x => x.JsonSerializer).Returns(new JsonSerializer());

            var hubProxy = new HubProxy(connection.Object, "foo");

            TestUtilities.AssertAggregateException(() => hubProxy.Invoke("Invoke").Wait(),
                                     "This in an error");
        }
コード例 #15
0
 public void RequestSourceInstances()
 {
     HubProxy.Invoke("RequestSourceInstances");
 }
コード例 #16
0
 public void RequestDigitalWalls()
 {
     HubProxy.Invoke("RequestDigitalWalls");
 }
コード例 #17
0
 public void RequestSpaceSessions()
 {
     HubProxy.Invoke("RequestSpaceSessions");
 }
コード例 #18
0
        public async Task <int> RemoveSpaceSession(int spaceSessionId)
        {
            int id = await HubProxy.Invoke <int>("RemoveSpaceSession", spaceSessionId);

            return(id);
        }
コード例 #19
0
        public void HubCallbackClearedOnFailedInvocation()
        {
            var connection = new Mock<HubConnection>("http://foo");
            var tcs = new TaskCompletionSource<object>();

            tcs.TrySetCanceled();

            connection.Setup(c => c.Send(It.IsAny<string>())).Returns(tcs.Task);

            var hubProxy = new HubProxy(connection.Object, "foo");

            var aggEx = Assert.Throws<AggregateException>(() => { hubProxy.Invoke("foo", "arg1").Wait(); });
            var ex = aggEx.Unwrap();

            Assert.IsType(typeof(TaskCanceledException), ex);

            Assert.Equal(connection.Object._callbacks.Count, 0);
        }
コード例 #20
0
        public void InvokeEventRaisesEvent()
        {
            var connection = new Mock<IHubConnection>();
            connection.SetupGet(x => x.JsonSerializer).Returns(new JsonSerializer());

            var hubProxy = new HubProxy(connection.Object, "foo");
            bool eventRaised = false;

            hubProxy.On("foo", () =>
            {
                eventRaised = true;
            });

            hubProxy.InvokeEvent("foo", new JToken[] { });
            Assert.True(eventRaised);
        }
コード例 #21
0
        public async Task <SetInfoResult> SetInfoAsyncLite(
            string strRemoteUserName,
            SetInfoRequest request,
            TimeSpan timeout,
            CancellationToken token)
        {
            SetInfoResult result = new SetInfoResult();

            if (result.Entities == null)
            {
                result.Entities = new List <Entity>();
            }

            if (string.IsNullOrEmpty(request.TaskID) == true)
            {
                request.TaskID = Guid.NewGuid().ToString();
            }

            using (WaitEvents wait_events = new WaitEvents())
            {
                using (var handler = HubProxy.On <
                           string, long, IList <Entity>, string>(
                           "responseSetInfo",
                           (taskID, resultValue, entities, errorInfo) =>
                {
                    if (taskID != request.TaskID)
                    {
                        return;
                    }

                    // 装载命中结果
                    if (entities != null)
                    {
                        result.Entities.AddRange(entities);
                    }
                    result.Value = resultValue;
                    result.ErrorInfo = errorInfo;
                    wait_events.finish_event.Set();
                }))
                {
                    MessageResult message = await HubProxy.Invoke <MessageResult>(
                        "RequestSetInfo",
                        strRemoteUserName,
                        request).ConfigureAwait(false);

                    if (message.Value == -1 ||
                        message.Value == 0)
                    {
                        result.ErrorInfo = message.ErrorInfo;
                        result.Value     = -1;
                        result.String    = message.String;
                        return(result);
                    }

                    await WaitAsync(
                        request.TaskID,
                        wait_events,
                        timeout,
                        token).ConfigureAwait(false);

                    return(result);
                }
            }
        }
コード例 #22
0
        public async Task <NormalResult> ConnectAsync(string url,
                                                      string userName,
                                                      string password,
                                                      string parameters)
        {
            lock (_syncRoot)
            {
                CloseConnection();

                Connection = new HubConnection(url);

                // 一直到真正连接前才触发登录事件
                //if (this.Container != null)
                //    this.Container.TriggerLogin(this);

                //if (this.Container != null && this.Container.TraceWriter != null)
                //    Connection.TraceWriter = this.Container.TraceWriter;

                // Connection.Credentials = new NetworkCredential("testusername", "testpassword");
                Connection.Headers.Add("username", userName);
                Connection.Headers.Add("password", password);
                Connection.Headers.Add("parameters", parameters);

                HubProxy = Connection.CreateHubProxy("MyHub");

                {
                    var handler = HubProxy.On <string, IList <MessageRecord> >("addMessage",
                                                                               (name, messages) =>
                                                                               OnAddMessageRecieved(name, messages)
                                                                               );
                    _handlers.Add(handler);
                }

                /*
                 * // *** search
                 * {
                 *  var handler = HubProxy.On<SearchRequest>("search",
                 *  (param) => OnSearchRecieved(param)
                 *  );
                 *  _handlers.Add(handler);
                 * }
                 */

                /*
                 * // *** webCall
                 * {
                 *  var handler = HubProxy.On<WebCallRequest>("webCall",
                 *  (param) => OnWebCallRecieved(param)
                 *  );
                 *  _handlers.Add(handler);
                 * }
                 *
                 * // *** close
                 * {
                 *  var handler = HubProxy.On<CloseRequest>("close",
                 *  (param) => OnCloseRecieved(param)
                 *  );
                 *  _handlers.Add(handler);
                 * }
                 */
            }

            try
            {
                await Connection.Start().ConfigureAwait(false);

                _userName = userName;

                {
                    /*
                     * _exiting = false;
                     * AddInfoLine("成功连接到 " + this.ServerUrl);
                     * TriggerConnectionStateChange("Connected");
                     */
                    return(new NormalResult());
                }
            }
            catch (HttpRequestException ex)
            {
                return(new NormalResult
                {
                    Value = -1,
                    ErrorInfo = ex.Message,
                    ErrorCode = "HttpRequestException"
                });
            }
            catch (Microsoft.AspNet.SignalR.Client.HttpClientException ex)
            {
                Microsoft.AspNet.SignalR.Client.HttpClientException ex0 = ex as Microsoft.AspNet.SignalR.Client.HttpClientException;
                return(new NormalResult
                {
                    Value = -1,
                    ErrorInfo = ex.Message,
                    ErrorCode = ex0.Response.StatusCode.ToString()
                });
            }
            catch (AggregateException ex)
            {
                return(new NormalResult
                {
                    Value = -1,
                    ErrorInfo = GetExceptionText(ex)
                });
            }
            catch (Exception ex)
            {
                return(new NormalResult
                {
                    Value = -1,
                    ErrorInfo = ExceptionUtil.GetExceptionText(ex)
                });
            }
        }
コード例 #23
0
        public async Task <int> AddDigitalWall(UcDigitalWall digitalWall)
        {
            int id = await HubProxy.Invoke <int>("AddDigitalWall", DigitalWallMapper.GetDtoDigitalWallFromUcDigitalWall(digitalWall));

            return(id);
        }
コード例 #24
0
        // 新版 API,测试中
        public async Task <SearchResult> SearchAsyncLite(
            string strRemoteUserName,
            SearchRequest request,
            TimeSpan timeout,
            CancellationToken token)
        {
            ResultManager manager = new ResultManager();
            List <string> errors  = new List <string>();
            List <string> codes   = new List <string>();

            SearchResult result = new SearchResult();

            if (result.Records == null)
            {
                result.Records = new List <Record>();
            }

            if (string.IsNullOrEmpty(request.TaskID) == true)
            {
                request.TaskID = Guid.NewGuid().ToString();
            }

            using (WaitEvents wait_events = new WaitEvents())    // 表示中途数据到来
            {
                using (var handler = HubProxy.On <SearchResponse>(
                           "responseSearch",
                           (responseParam) =>
                {
                    try
                    {
                        if (responseParam.TaskID != request.TaskID)
                        {
                            return;
                        }

                        // Debug.WriteLine("handler called. responseParam\r\n***\r\n" + responseParam.Dump() + "***\r\n");

                        // 装载命中结果
                        if (responseParam.ResultCount == -1 && responseParam.Start == -1)
                        {
                            if (result.ResultCount != -1)
                            {
                                result.ResultCount = manager.GetTotalCount();
                            }
                            //result.ErrorInfo = responseParam.ErrorInfo;
                            //result.ErrorCode = responseParam.ErrorCode;
                            result.ErrorInfo = StringUtil.MakePathList(errors, "; ");
                            result.ErrorCode = StringUtil.MakePathList(codes, ",");

                            Debug.WriteLine("finish_event.Set() 1");
                            wait_events.finish_event.Set();
                            return;
                        }

                        // TODO: 似乎应该关注 start 位置
                        if (responseParam.Records != null)
                        {
                            AddLibraryUID(responseParam.Records, responseParam.LibraryUID);
                        }

                        result.Records.AddRange(responseParam.Records);
                        if (string.IsNullOrEmpty(responseParam.ErrorInfo) == false &&
                            errors.IndexOf(responseParam.ErrorInfo) == -1)
                        {
                            errors.Add(responseParam.ErrorInfo);
                            result.ErrorInfo = StringUtil.MakePathList(errors, "; ");
                        }
                        if (string.IsNullOrEmpty(responseParam.ErrorCode) == false &&
                            codes.IndexOf(responseParam.ErrorCode) == -1)
                        {
                            codes.Add(responseParam.ErrorCode);
                            result.ErrorCode = StringUtil.MakePathList(codes, ",");
                        }

                        // 标记结束一个检索目标
                        // return:
                        //      0   尚未结束
                        //      1   结束
                        //      2   全部结束
                        int nRet = manager.CompleteTarget(responseParam.LibraryUID,
                                                          responseParam.ResultCount,
                                                          responseParam.Records == null ? 0 : responseParam.Records.Count);

                        if (responseParam.ResultCount == -1)
                        {
                            result.ResultCount = -1;
                        }
                        else
                        {
                            result.ResultCount = manager.GetTotalCount();
                        }

#if NO
                        if (nRet == 2)
                        {
                            Debug.WriteLine("finish_event.Set() 2");
                            wait_events.finish_event.Set();
                        }
                        else
                        {
                            wait_events.active_event.Set();
                        }
#endif
                        wait_events.active_event.Set();
                    }
                    catch (Exception ex)
                    {
                        errors.Add("SearchAsync handler 内出现异常: " + ExceptionUtil.GetDebugText(ex));
                        result.ErrorInfo = StringUtil.MakePathList(errors, "; ");
                        if (!(ex is ObjectDisposedException))
                        {
                            wait_events.finish_event.Set();
                        }
                    }
                }))
                {
                    MessageResult message = await HubProxy.Invoke <MessageResult>(
                        "RequestSearch",
                        strRemoteUserName,
                        request).ConfigureAwait(false);

                    if (message.Value == -1 || message.Value == 0)
                    {
                        result.ErrorInfo   = message.ErrorInfo;
                        result.ResultCount = -1;
                        result.ErrorCode   = message.String;
                        Debug.WriteLine("return pos 1");
                        return(result);
                    }

                    if (manager.SetTargetCount(message.Value) == true)
                    {
                        Debug.WriteLine("return pos 2");
                        return(result);
                    }

                    try
                    {
                        // TODO: 当检索一个目标的时候,不应该长时间等待其他目标
                        await WaitAsync(
                            request.TaskID,
                            wait_events,
                            timeout,
                            token).ConfigureAwait(false);
                    }
                    catch (TimeoutException)
                    {
                        // 超时的时候实际上有结果了
                        if (result.Records != null &&
                            result.Records.Count > 0)
                        {
                            result.ErrorCode += ",_timeout";    // 附加一个错误码,表示虽然返回了结果,但是已经超时
                            Debug.WriteLine("return pos 3");
                            return(result);
                        }
                        throw;
                    }

                    Debug.WriteLine("return pos 4");
                    return(result);
                }
            }
        }
コード例 #25
0
        // 对于 .data 超过 chunk_size 的情况可以自动切割为多次发送请求
        public async Task <SetMessageResult> SetMessageAsyncLite(
            SetMessageRequest request)
        {
            // 请求结构中如果具备了 TaskID 值,说明调主想自己控制拼接过程,那这里就直接发送出去
            if (string.IsNullOrEmpty(request.TaskID) == false)
            {
                return(await TrySetMessageAsync(request).ConfigureAwait(false));
            }

            int chunk_size = 4096;
            int length     = GetLength(request);

            if (length < chunk_size)
            {
                return(await TrySetMessageAsync(request));
            }

            SetMessageResult result = null;

            foreach (MessageRecord record in request.Records)
            {
                string taskID = Guid.NewGuid().ToString();
                string data   = record.data;
                int    send   = 0;
                for (; ;)
                {
                    SetMessageRequest current_request = new SetMessageRequest();
                    current_request.TaskID  = taskID;
                    current_request.Style   = request.Style;
                    current_request.Action  = request.Action;
                    current_request.Records = new List <MessageRecord>();
                    MessageRecord current_record = new MessageRecord();
                    // TODO: 除了第一次请求外,其它的都只要 .data 成员具备即可
                    current_record.CopyFrom(record);
                    current_record.data = data.Substring(send, Math.Min(chunk_size, data.Length - send));
                    current_request.Records.Add(current_record);
                    // 这一次就是最后一次
                    if (send + current_record.data.Length >= data.Length)
                    {
                        MessageRecord tail_record = new MessageRecord();
                        tail_record.data = null;    // 表示结束
                        current_request.Records.Add(tail_record);
                    }

                    // TODO:
#if NO
                    result = await HubProxy.Invoke <SetMessageResult>(
                        "SetMessage",
                        current_request);
#endif
                    result = await TrySetMessageAsync(current_request).ConfigureAwait(false);

                    if (result.Value == -1)
                    {
                        return(result);  // 中途出错了
                    }
                    send += current_record.data.Length;
                    if (send >= data.Length)
                    {
                        break;
                    }
                }
            }

            return(result);  // 返回最后一次请求的 result 值
        }
コード例 #26
0
        public async Task <MessageResult> GetMessageAsyncLite(
            GetMessageRequest request,
            Delegate_outputMessage proc,
            TimeSpan timeout,
            CancellationToken token)
        {
            MessageResult result = new MessageResult();

            if (string.IsNullOrEmpty(request.TaskID) == true)
            {
                request.TaskID = Guid.NewGuid().ToString();
            }

            long recieved = 0;

            StringBuilder cache = new StringBuilder();

            using (WaitEvents wait_events = new WaitEvents())    // 表示中途数据到来
            {
                using (var handler = HubProxy.On <
                           string, long, long, IList <MessageRecord>, string, string>(
                           "responseGetMessage",
                           (taskID, resultCount, start, records, errorInfo, errorCode) =>
                {
                    if (taskID != request.TaskID)
                    {
                        return;
                    }

                    if (resultCount == -1 || start == -1)
                    {
                        if (start == -1)
                        {
                            // 表示发送响应过程已经结束。只是起到通知的作用,不携带任何信息
                            // result.Finished = true;
                        }
                        else
                        {
                            result.Value = resultCount;
                            result.ErrorInfo = errorInfo;
                            result.String = errorCode;
                        }
                        wait_events.finish_event.Set();
                        return;
                    }

                    proc(
                        cache,
                        resultCount,
                        start,
                        records,
                        errorInfo,
                        errorCode);

                    if (records != null)
                    {
                        recieved += GetCount(records);      // records.Count;
                    }
                    if (errorCode == "_complete")
                    {
                        result.Value = resultCount;
                        wait_events.finish_event.Set();
                        return;
                    }

                    if (resultCount >= 0 &&
                        IsComplete(request.Start, request.Count, resultCount, recieved) == true)
                    {
                        wait_events.finish_event.Set();
                    }
                    else
                    {
                        wait_events.active_event.Set();
                    }
                }))
                {
                    MessageResult temp = await HubProxy.Invoke <MessageResult>(
                        "RequestGetMessage",
                        request).ConfigureAwait(false);

                    if (temp.Value == -1 || temp.Value == 0 || temp.Value == 2)
                    {
                        return(temp);
                    }

                    // result.String 里面是返回的 taskID

                    await WaitAsync(
                        request.TaskID,
                        wait_events,
                        timeout,
                        token).ConfigureAwait(false);

                    return(result);
                }
            }
        }
コード例 #27
0
 private static void SendMessage(string message)
 {
     HubProxy.Invoke("BroadcastMessage", message);
 }
コード例 #28
0
        public async Task <int> RemoveSourceInstance(int sourceInstanceId)
        {
            int id = await HubProxy.Invoke <int>("RemoveSourceInstance", sourceInstanceId);

            return(id);
        }
コード例 #29
0
ファイル: HubConnection.cs プロジェクト: hallco978/SignalR
        /// <summary>
        /// Creates an <see cref="IHubProxy"/> for the hub with the specified name.
        /// </summary>
        /// <param name="hubName">The name of the hub.</param>
        /// <returns>A <see cref="IHubProxy"/></returns>
        public IHubProxy CreateHubProxy(string hubName)
        {
            if (State != ConnectionState.Disconnected)
            {
                throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, Resources.Error_ProxiesCannotBeAddedConnectionStarted));
            }

            HubProxy hubProxy;
            if (!_hubs.TryGetValue(hubName, out hubProxy))
            {
                hubProxy = new HubProxy(this, hubName);
                _hubs[hubName] = hubProxy;
            }
            return hubProxy;
        }
コード例 #30
0
        public async Task <int> AddSourceInstance(UcSourceInstance sourceInstance)
        {
            int id = await HubProxy.Invoke <int>("AddSourceInstance", SourceInstanceMapper.GetDtoSourceInstanceFromUcSourceInstance(sourceInstance));

            return(id);
        }
コード例 #31
0
        public void InvokeEventRaisesEventWithData()
        {
            var connection = new Mock<IHubConnection>();
            connection.SetupGet(x => x.JsonSerializer).Returns(new JsonSerializer());

            var hubProxy = new HubProxy(connection.Object, "foo");
            bool eventRaised = false;

            hubProxy.On<int>("foo", (i) =>
            {
                eventRaised = true;
                Assert.Equal(1, i);
            });

            hubProxy.InvokeEvent("foo", new[] { JToken.FromObject(1) });
            Assert.True(eventRaised);
        }
コード例 #32
0
        public void InvokeWorksWithNullArgument()
        {
            var connection = new Mock<IHubConnection>();
            connection.Setup(c => c.RegisterCallback(It.IsAny<Action<HubResult>>()))
                      .Callback<Action<HubResult>>(callback =>
                      {
                          callback(new HubResult());
                      });

            connection.Setup(m => m.Send(It.IsAny<string>())).Returns(TaskAsyncHelper.Empty);
            connection.SetupGet(x => x.JsonSerializer).Returns(new JsonSerializer());

            var hubProxy = new HubProxy(connection.Object, "foo");

            var o = new NullInvokeTest { Name = null, Number = 42, Strings = new[] { "Kazimierz", null, "Tetmajer" } };
            hubProxy.Invoke("method", 1, null, new[] { "a", "b" }, o);

            connection.Verify(
                c => c.Send(@"{""I"":null,""H"":""foo"",""M"":""method""," +
                @"""A"":[1,null,[""a"",""b""],{""Name"":null,""Number"":42,""Strings"":[""Kazimierz"",null,""Tetmajer""]}]}"),
                Times.Once());
        }
コード例 #33
0
        public void FailedHubCallbackDueToReconnectFollowedByInvoke()
        {
            // Arrange
            var testTcs = new TaskCompletionSource<object>();
            var crashTcs = new TaskCompletionSource<object>();
            var connection = new HubConnection("http://test");
            var transport = new Mock<IClientTransport>();

            transport.Setup(t => t.Negotiate(connection, /* connectionData: */ It.IsAny<string>()))
                     .Returns(TaskAsyncHelper.FromResult(new NegotiationResponse
                     {
                         ProtocolVersion = connection.Protocol.ToString(),
                         ConnectionId = "Something",
                         DisconnectTimeout = 120
                     }));

            transport.Setup(t => t.Start(connection, /* connectionData: */ It.IsAny<string>(), /* disconnectToken: */ It.IsAny<CancellationToken>()))
                     .Returns(TaskAsyncHelper.Empty);

            transport.Setup(t => t.Send(connection, /* data: */ It.Is<string>(s => s.IndexOf("crash") >= 0), /* connectionData: */ It.IsAny<string>()))
                     .Returns(crashTcs.Task) // We want this task to never complete as the call to EnsureReconnecting will do it for us
                     .Callback(() =>
                     {
                         Task.Run(() =>
                         {
                             try
                             {
                                 // EnsureReconnecting will change the state and ultimately clear the pending invocation callbacks
                                 connection.EnsureReconnecting();
                                 testTcs.SetResult(null);
                             }
                             catch (Exception ex)
                             {
                                 testTcs.SetException(ex);
                             }
                         });
                     });

            var proxy = new HubProxy(connection, "test");

            // Act
            connection.Start(transport.Object).Wait();
            var crashTask = proxy.Invoke("crash")
                .ContinueWith(t => proxy.Invoke("test"),
                    TaskContinuationOptions.ExecuteSynchronously); // We need to ensure this executes sync so we're on the same stack

            // Assert
            Assert.Throws(typeof(AggregateException), () => crashTask.Wait());
            Assert.DoesNotThrow(() => testTcs.Task.Wait());
        }
コード例 #34
0
 // 请求服务器中断一个 task
 public Task <MessageResult> CancelSearchAsync(string taskID)
 {
     return(HubProxy.Invoke <MessageResult>(
                "CancelSearch",
                taskID));
 }
コード例 #35
0
        public async Task <int> RemoveDigitalWall(int digitalWallId)
        {
            int id = await HubProxy.Invoke <int>("RemoveDigitalWall", digitalWallId);

            return(id);
        }
コード例 #36
-1
ファイル: HubProxyTest.cs プロジェクト: ninjaAB/SignalR
        public void GetSubscriptionsReturnsListOfSubscriptions()
        {
            var connection = new Mock<SignalR.Client.IConnection>();
            var hubProxy = new HubProxy(connection.Object, "foo");

            hubProxy.On<int>("foo", i => { });

            hubProxy.On("baz", () => { });

            var subscriptions = hubProxy.GetSubscriptions().ToList();
            Assert.Equal(2, subscriptions.Count);
            Assert.Equal("foo", subscriptions[0]);
            Assert.Equal("baz", subscriptions[1]);
        }