示例#1
0
            /// <summary>
            /// Constructor
            /// </summary>
            /// <param name="manager">Manager</param>
            /// <param name="functionName">Function name</param>
            /// <param name="callback">Callback for data</param>
            /// <param name="param">End point parameters, each array of strings is a separate call to the end point function</param>
            /// <returns>Connection</returns>
            public async Task OpenAsync(SignalrManager manager, string functionName, Action <string> callback, string[][] param = null)
            {
                if (callback != null)
                {
                    param = (param ?? new string[][] { new string[0] });
                    manager.AddListener(functionName, callback, param);
                    string functionFullName = manager.GetFunctionFullName(functionName);
                    bool   result           = true;
                    foreach (string[] p in param)
                    {
                        result &= await manager.hubProxy.Invoke <bool>(functionFullName, p);
                    }
                    if (result)
                    {
                        this.manager          = manager;
                        this.callback         = callback;
                        this.functionFullName = functionFullName;
                        lock (manager.sockets)
                        {
                            manager.sockets.Add(this);
                        }
                        return;
                    }

                    // fail, remove listener
                    manager.RemoveListener(functionName, callback);
                }

                throw new APIException("Unable to open web socket to Bittrex");
            }
示例#2
0
            /// <summary>
            /// Constructor
            /// </summary>
            /// <param name="functionName">Function name</param>
            /// <param name="callback">Callback for data</param>
            /// <param name="delayMilliseconds">Delay after invoking each object[] in param, used if the server will disconnect you for too many invoke too fast</param>
            /// <param name="param">End point parameters, each array of strings is a separate call to the end point function. For no parameters, pass null.</param>
            /// <returns>Connection</returns>
            public async Task OpenAsync(string functionName, Action <string> callback, int delayMilliseconds = 0, object[][] param = null)
            {
                if (callback != null)
                {
                    param = (param ?? new object[][] { new object[0] });
                    manager.AddListener(functionName, callback, param);
                    string    functionFullName = manager.GetFunctionFullName(functionName);
                    Exception ex = null;
                    try
                    {
                        for (int i = 0; i < param.Length; i++)
                        {
                            if (i != 0)
                            {
                                await Task.Delay(delayMilliseconds);
                            }
                            if (!(await manager.hubProxy.Invoke <bool>(functionFullName, param[i])))
                            {
                                throw new APIException("Invoke returned success code of false");
                            }
                        }
                    }
                    catch (Exception _ex)
                    {
                        ex = _ex;
                        Console.WriteLine("Error invoking hub proxy {0}: {1}", functionFullName, ex);
                    }
                    if (ex == null)
                    {
                        this.callback         = callback;
                        this.functionFullName = functionFullName;
                        lock (manager.sockets)
                        {
                            manager.sockets.Add(this);
                        }
                        return;
                    }

                    // fail, remove listener
                    manager.RemoveListener(functionName, callback);
                    throw ex;
                }
                throw new ArgumentNullException(nameof(callback));
            }
            /// <summary>
            /// Constructor
            /// </summary>
            /// <param name="functionName">Function name</param>
            /// <param name="callback">Callback for data</param>
            /// <param name="delayMilliseconds">Delay after invoking each object[] in param, used if the server will disconnect you for too many invoke too fast</param>
            /// <param name="param">End point parameters, each array of strings is a separate call to the end point function. For no parameters, pass null.</param>
            /// <returns>Connection</returns>
            public async Task OpenAsync(string functionName, Func <string, Task> callback, int delayMilliseconds = 0, object[][] param = null)
            {
                if (callback != null)
                {
                    SignalrManager _manager = this.manager;
                    if (_manager == null)
                    {
                        throw new ArgumentNullException("SignalrManager is null");
                    }
                    param = (param ?? new object[][] { new object[0] });
                    await _manager.AddListener(functionName, callback, param);

                    // ask for proxy after adding the listener, as the listener will force a connection if needed
                    IHubProxy _proxy = _manager.hubProxy;
                    if (_proxy == null)
                    {
                        throw new ArgumentNullException("Hub proxy is null");
                    }
                    string    functionFullName = _manager.GetFunctionFullName(functionName);
                    Exception ex = null;
                    try
                    {
                        for (int i = 0; i < param.Length; i++)
                        {
                            if (i != 0)
                            {
                                await Task.Delay(delayMilliseconds);
                            }
                            if (!(await _proxy.Invoke <bool>(functionFullName, param[i])))
                            {
                                throw new APIException("Invoke returned success code of false");
                            }
                        }
                    }
                    catch (Exception _ex)
                    {
                        ex = _ex;
                        Console.WriteLine("Error invoking hub proxy {0}: {1}", functionFullName, ex);
                    }
                    if (ex == null)
                    {
                        this.callback         = callback;
                        this.functionFullName = functionFullName;
                        lock (_manager.sockets)
                        {
                            _manager.sockets.Add(this);
                        }
                        return;
                    }

                    // fail, remove listener
                    _manager.RemoveListener(functionName, callback);
                    throw ex;
                }
                throw new ArgumentNullException(nameof(callback));
            }
示例#4
0
            /// <summary>
            /// Constructor
            /// </summary>
            /// <param name="manager">Manager</param>
            /// <param name="functionName">Function name</param>
            /// <param name="callback">Callback for data</param>
            /// <param name="param">End point parameters</param>
            /// <returns>Connection</returns>
            public async Task OpenAsync(SignalrManager manager, string functionName, Action <string> callback, params object[] param)
            {
                if (callback != null)
                {
                    manager.AddListener(functionName, callback, param);
                    string functionFullName = manager.GetFunctionFullName(functionName);
                    bool   result           = await manager.hubProxy.Invoke <bool>(functionFullName, param);

                    if (result)
                    {
                        this.manager          = manager;
                        this.callback         = callback;
                        this.functionFullName = functionFullName;
                        return;
                    }

                    // fail, remove listener
                    manager.RemoveListener(functionName, callback);
                }

                throw new APIException("Unable to open web socket to Bittrex");
            }
示例#5
0
 /// <summary>
 /// Dispose of the socket and remove from listeners
 /// </summary>
 public void Dispose()
 {
     try
     {
         lock (manager.sockets)
         {
             manager.sockets.Remove(this);
         }
         manager.RemoveListener(functionFullName, callback);
         Disconnected?.Invoke(this);
     }
     catch
     {
     }
 }
示例#6
0
            /// <summary>
            /// Dispose of the socket and remove from listeners
            /// </summary>
            public void Dispose()
            {
                if (disposed)
                {
                    return;
                }
                disposed = true;

                try
                {
                    lock (manager.sockets)
                    {
                        manager.sockets.Remove(this);
                    }
                    manager.RemoveListener(functionFullName, callback);
                    InvokeDisconnected().Sync();
                }
                catch
                {
                }
            }
示例#7
0
            /// <summary>
            /// Constructor
            /// </summary>
            /// <param name="functionName">Function name</param>
            /// <param name="callback">Callback for data</param>
            /// <param name="delayMilliseconds">Delay after invoking each object[] in param, used if the server will disconnect you for too many invoke too fast</param>
            /// <param name="param">End point parameters, each array of strings is a separate call to the end point function. For no parameters, pass null.</param>
            /// <returns>Connection</returns>
            public async Task OpenAsync(string functionName, Func <string, Task> callback, int delayMilliseconds = 0, object[][] param = null)
            {
                if (callback == null)
                {
                    throw new ArgumentNullException(nameof(callback));
                }

                SignalrManager _manager = this.manager;

                if (_manager == null)
                {
                    throw new ArgumentNullException("SignalrManager is null");
                }

                Exception ex = null;

                param = (param ?? new object[][] { new object[0] });
                string functionFullName = _manager.GetFunctionFullName(functionName);

                this.functionFullName = functionFullName;

                while (true)
                {
                    await _manager.AddListener(functionName, callback, param);

                    try
                    {
                        // ask for proxy after adding the listener, as the listener will force a connection if needed
                        IHubProxy _proxy = _manager.hubProxy;
                        if (_proxy == null)
                        {
                            throw new ArgumentNullException("Hub proxy is null");
                        }

                        // all parameters must succeed or we will give up and try the loop all over again
                        for (int i = 0; i < param.Length; i++)
                        {
                            if (i != 0)
                            {
                                await Task.Delay(delayMilliseconds);
                            }
                            bool result = await _proxy.Invoke <bool>(functionFullName, param[i]).ConfigureAwait(false);

                            if (!result)
                            {
                                throw new APIException("Invoke returned success code of false");
                            }
                        }
                        break;
                    }
                    catch (Exception _ex)
                    {
                        // fail, remove listener
                        _manager.RemoveListener(functionName, callback);
                        ex = _ex;
                        Logger.Info("Error invoking hub proxy {0}: {1}", functionFullName, ex);
                        if (disposed || manager.disposed)
                        {
                            // give up, if we or the manager is disposed we are done
                            break;
                        }
                        else
                        {
                            // try again in a bit...
                            await Task.Delay(500);
                        }
                    }
                }

                if (ex == null)
                {
                    this.callback = callback;
                    lock (_manager.sockets)
                    {
                        _manager.sockets.Add(this);
                    }
                    return;
                }
            }
示例#8
0
            /// <summary>
            /// Constructor
            /// </summary>
            /// <param name="functionName">Function name</param>
            /// <param name="callback">Callback for data</param>
            /// <param name="delayMilliseconds">Delay after invoking each object[] in param, used if the server will disconnect you for too many invoke too fast</param>
            /// <param name="param">End point parameters, each array of strings is a separate call to the end point function. For no parameters, pass null.</param>
            /// <returns>Connection</returns>
            public async Task OpenAsync(string functionName, Func <string, Task> callback, int delayMilliseconds = 0, object[][] param = null)
            {
                callback.ThrowIfNull(nameof(callback), "Callback must not be null");

                SignalrManager _manager = this.manager;

                _manager.ThrowIfNull(nameof(manager), "Manager is null");

                Exception ex = null;

                param = (param ?? new object[][] { new object[0] });
                string functionFullName = _manager.GetFunctionFullName(functionName);

                this.functionFullName = functionFullName;

                while (!_manager.disposed)
                {
                    await _manager.AddListener(functionName, callback, param);

                    if (_manager.hubConnection.State != ConnectionState.Connected)
                    {
                        await Task.Delay(100);

                        continue;
                    }

                    try
                    {
                        // ask for proxy after adding the listener, as the listener will force a connection if needed
                        IHubProxy _proxy = _manager.hubProxy;
                        if (_proxy == null)
                        {
                            throw new ArgumentNullException("Hub proxy is null");
                        }

                        // all parameters must succeed or we will give up and try the loop all over again
                        for (int i = 0; i < param.Length; i++)
                        {
                            if (i != 0)
                            {
                                await Task.Delay(delayMilliseconds);
                            }
                            bool result = await _proxy.Invoke <bool>(functionFullName, param[i]).ConfigureAwait(false);

                            if (!result)
                            {
                                throw new APIException("Invoke returned success code of false");
                            }
                        }
                        break;
                    }
                    catch (Exception _ex)
                    {
                        // fail, remove listener
                        _manager.RemoveListener(functionName, callback);
                        ex = _ex;
                        Logger.Info("Error invoking hub proxy {0}: {1}", functionFullName, ex);
                        if (disposed || manager.disposed)
                        {
                            // give up, if we or the manager is disposed we are done
                            break;
                        }
                        else
                        {
                            // try again in a bit...
                            await Task.Delay(500);
                        }
                    }
                }

                if (ex == null)
                {
                    this.callback = callback;
                    lock (_manager.sockets)
                    {
                        _manager.sockets.Add(this);
                    }
                    if (!initialConnectFired)
                    {
                        initialConnectFired = true;

                        // kick off a connect event if this is the first time, the connect even can only get set after the open request is sent
                        Task.Delay(1000).ContinueWith(async(t) => { await InvokeConnected(); }).ConfigureAwait(false).GetAwaiter();
                    }
                    return;
                }
            }