// This call is made (once) from Excel to subscribe to the topic. public IDisposable Subscribe(IExcelObserver observer) { // We know this will only be called once, so we take some adventurous shortcuts (like returning 'this') Observer = observer; Observer.OnNext(Handle); return(this); }
public IDisposable Subscribe(IExcelObserver observer) { lock (_observerLock) { if (_observer != null) { throw new InvalidOperationException("Only single Subscription allowed."); } _observer = observer; if (_hasResult) { if (_exception != null) { _observer.OnError(_exception); } else { _observer.OnNext(_result); _observer.OnCompleted(); } } } return(DummyDisposable.Instance); }
public IDisposable Subscribe(IExcelObserver observer) { if (_subscribed) { throw new InvalidOperationException("Only single Subscription allowed."); } _subscribed = true; ThreadPool.QueueUserWorkItem(delegate { try { object result = _func(); observer.OnNext(result); observer.OnCompleted(); } catch (Exception ex) { // TODO: Log somehow? observer.OnError(ex); } }); return(DummyDisposable.Instance); }
IDisposable IExcelObservable.Subscribe(IExcelObserver observer) { Debug.Assert(_observer == null); _observer = observer; ReportState(); // Reporting immediately in the Subscribe means we never return #N/A from into the cell return(this); }
// This call is made (once) from Excel to subscribe to the topic. public IDisposable Subscribe(IExcelObserver observer) { // We know this will only be called once, so we take some adventurous shortcuts (like returning 'this') Observer = observer; Observer.OnNext(Handle); return this; }
public void PreDispose() { this.__ExcelObserver = null; this.ConfigMatter = null; if (this.PMMLMatter != null) { this.PMMLMatter.Dispose(); } this.PMMLMatter = null; if (this.InputMatter != null) { this.InputMatter.Dispose(); } this.InputMatter = null; if (this.OutputMatter != null) { this.OutputMatter.Dispose(); } this.OutputMatter = null; //C# GC.Collect(); //C# GC.WaitForPendingFinalizers(); //C# GC.Collect(); //C# GC.WaitForPendingFinalizers(); }
public IDisposable Subscribe(IExcelObserver observer) { #if DEBUG return(new DebuggingDisposable(_observable.Subscribe(value => observer.OnNext(value), observer.OnError, observer.OnCompleted))); #else return(_observable.Subscribe(value => observer.OnNext(value), observer.OnError, observer.OnCompleted)); #endif }
public IDisposable Subscribe(IExcelObserver observer) { var timer = new System.Timers.Timer(); timer.Interval = 1000; timer.Elapsed += (s, e) => observer.OnNext(DateTime.Now.ToString()); timer.Start(); return(new TickerDisposable(timer)); }
public IDisposable Subscribe(IExcelObserver observer) { _observer = observer; _rtdClient.OnServiceStatusReceived += OnServiceStatusReceived; _observer.OnNext(_rtdClient.GetServiceStatus().ToString()); return(new ActionDisposable(CleanUp)); }
public IDisposable Subscribe(IExcelObserver observer) { _observer = observer; _rtdClient.OnConnectionStatusChanged += OnConnectionStatusChanged; _observer.OnNext(_rtdClient.State.ToString()); return(new ActionDisposable(CleanUp)); }
public IDisposable Subscribe(IExcelObserver observer) { _observer = observer; _monitor.AvailableEndpointsChanged += OnAvailableEndpointsChanged; SendConnectionList(); return(new ActionDisposable(CleanUp)); }
public IDisposable Subscribe(IExcelObserver observer) { _socket.On(_feed, (data) => { ValueSentEventArgs value = data.Json.GetFirstArgAs <ValueSentEventArgs>(); observer.OnNext(value.Calculation); }); return(_observable.Subscribe(value => observer.OnNext(value), observer.OnError, observer.OnCompleted)); }
public IDisposable Subscribe(IExcelObserver observer) { _observer = observer; _rtdClient.SubscribeToSystemValue(SystemProperty); _rtdClient.OnSystemValueReceived += OnPortfolioDateReceived; _observer.OnNext(ExcelEmpty.Value); return(new ActionDisposable(CleanUp)); }
public IDisposable Subscribe(IExcelObserver observer) { _observer = observer; _rtdClient.SubscribeToPositionValue(PositionId, Column); _rtdClient.OnPositionValueReceived += OnDataReceived; _observer.OnNext(ExcelEmpty.Value); return(new ActionDisposable(CleanUp)); }
public IDisposable Subscribe(IExcelObserver observer) { lock (this) { m_observer = observer; // Might be a problem if we want to support valid null values. if (Value != null) { m_observer.OnNext(HandleName); } return(this); } }
public IDisposable Subscribe(IExcelObserver observer) { switch (_task.Status) { case TaskStatus.RanToCompletion: observer.OnNext(_task.Result); observer.OnCompleted(); break; case TaskStatus.Faulted: observer.OnError(_task.Exception.InnerException); break; case TaskStatus.Canceled: observer.OnError(new TaskCanceledException(_task)); break; default: _task.ContinueWith(t => { switch (t.Status) { case TaskStatus.RanToCompletion: observer.OnNext(t.Result); observer.OnCompleted(); break; case TaskStatus.Faulted: observer.OnError(t.Exception.InnerException); break; case TaskStatus.Canceled: observer.OnError(new TaskCanceledException(t)); break; } }); break; } // Check for cancellation support if (_cts != null) { return(new CancellationDisposable(_cts)); } // No cancellation return(DefaultDisposable.Instance); }
public IDisposable Subscribe(IExcelObserver observer) { _observer = observer; _rtdClient.OnConnectionStatusChanged += OnConnectionStatusChanged; if (_rtdClient.Connection is object) { _observer.OnNext(ConnectionHelper.GetConnectionId(_rtdClient.Connection.Uri)); } else { _observer.OnNext(Resources.NotConnectedMessage); } return(new ActionDisposable(CleanUp)); }
public IDisposable Subscribe(IExcelObserver observer) { switch (_task.Status) { case TaskStatus.RanToCompletion: observer.OnNext(_task.Result); observer.OnCompleted(); break; case TaskStatus.Faulted: observer.OnError(_task.Exception.InnerException); break; case TaskStatus.Canceled: observer.OnError(new TaskCanceledException(_task)); break; default: var task = _task; // OK - the Task has not completed synchronously // And handle the Task completion task.ContinueWith(t => { switch (t.Status) { case TaskStatus.RanToCompletion: observer.OnNext(t.Result); observer.OnCompleted(); break; case TaskStatus.Faulted: observer.OnError(t.Exception.InnerException); break; case TaskStatus.Canceled: observer.OnError(new TaskCanceledException(t)); break; } }); break; } return(DefaultDisposable.Instance); }
public IDisposable Subscribe(IExcelObserver observer) { return(observable_.Subscribe(new ExcelObserverImpl(observer))); }
public IDisposable Subscribe(IExcelObserver arg) { this.__ExcelObserver = arg; this.__ExcelObserver.OnNext(this.HandleMajorMinor); return(this); }
public ExcelObserverImpl(IExcelObserver excelObserver) { excelObserver_ = excelObserver; }
public IDisposable Subscribe(IExcelObserver observer) { // Start with a disposable that does nothing // Possibly set to a CancellationDisposable later IDisposable disp = DefaultDisposable.Instance; switch (_task.Status) { case TaskStatus.RanToCompletion: observer.OnNext(_task.Result); observer.OnCompleted(); break; case TaskStatus.Faulted: observer.OnError(_task.Exception.InnerException); break; case TaskStatus.Canceled: observer.OnError(new TaskCanceledException(_task)); break; default: var task = _task; // OK - the Task has not completed synchronously // First set up a continuation that will suppress Cancel after the Task completes if (_cts != null) { var cancelDisp = new CancellationDisposable(_cts); task = _task.ContinueWith(t => { cancelDisp.SuppressCancel(); return(t); }).Unwrap(); // Then this will be the IDisposable we return from Subscribe disp = cancelDisp; } // And handle the Task completion task.ContinueWith(t => { switch (t.Status) { case TaskStatus.RanToCompletion: observer.OnNext(t.Result); observer.OnCompleted(); break; case TaskStatus.Faulted: observer.OnError(t.Exception.InnerException); break; case TaskStatus.Canceled: observer.OnError(new TaskCanceledException(t)); break; } }); break; } return(disp); }
public IDisposable Subscribe(IExcelObserver excelObserver) { var observer = new AnonymousObserver <T>(value => excelObserver.OnNext(value), excelObserver.OnError, excelObserver.OnCompleted); return(_observable.Subscribe(observer)); }
public void removeExcelObserver(IExcelObserver e) { mExcelObservers.Remove(e); }
public IDisposable Subscribe(IExcelObserver observer) { m_observer = observer; m_observer.OnNext(m_name); return(this); }
public IDisposable Subscribe(IExcelObserver observer) { _observers.Add(observer); observer.OnNext(DateTime.Now.ToString("HH:mm:ss.fff") + " (Subscribe)"); return(new ActionDisposable(() => _observers.Remove(observer))); }
public IDisposable Subscribe(IExcelObserver excelObserver) { _observer = excelObserver; OnSubscribe(); return(this); }
protected virtual void OnDispose() => _observer = null;
public IDisposable Subscribe(IExcelObserver observer) { return(_observable.Subscribe(value => observer.OnNext(value), observer.OnError, observer.OnCompleted)); }
public IDisposable Subscribe(IExcelObserver observer) { lock (_observerLock) { if (_observer != null) throw new InvalidOperationException("Only single Subscription allowed."); _observer = observer; if (_hasResult) { if (_exception != null) { _observer.OnError(_exception); } else { _observer.OnNext(_result); _observer.OnCompleted(); } } } return DummyDisposable.Instance; }
public IDisposable Subscribe(IExcelObserver observer) { if (_subscribed) throw new InvalidOperationException("Only single Subscription allowed."); _subscribed = true; ThreadPool.QueueUserWorkItem(delegate { try { object result = _func(); observer.OnNext(result); observer.OnCompleted(); } catch (Exception ex) { // TODO: Log somehow observer.OnError(ex); } }); return new DummyDisposable(); }
public void registerExcelObserver(IExcelObserver e) { mExcelObservers.Add(e); }
public IDisposable Subscribe(IExcelObserver observer) { switch (_task.Status) { case TaskStatus.RanToCompletion: observer.OnNext(_task.Result); observer.OnCompleted(); break; case TaskStatus.Faulted: observer.OnError(_task.Exception.InnerException); break; case TaskStatus.Canceled: observer.OnError(new TaskCanceledException(_task)); break; default: var task = _task; // OK - the Task has not completed synchronously // And handle the Task completion task.ContinueWith(t => { switch (t.Status) { case TaskStatus.RanToCompletion: observer.OnNext(t.Result); observer.OnCompleted(); break; case TaskStatus.Faulted: observer.OnError(t.Exception.InnerException); break; case TaskStatus.Canceled: observer.OnError(new TaskCanceledException(t)); break; } }); break; } return DefaultDisposable.Instance; }