public async Task ToAsyncEnumerable_Observable_Cancel_InFlight() { var xs = new MyObservable <int>(obs => { var cts = new CancellationTokenSource(); Task.Run(async() => { for (var i = 0; !cts.IsCancellationRequested; i++) { await Task.Delay(10); obs.OnNext(i); } }); return(new MyDisposable(cts.Cancel)); }).ToAsyncEnumerable(); using var c = new CancellationTokenSource(); await using var e = xs.GetAsyncEnumerator(c.Token); var task = e.MoveNextAsync(); c.Cancel(); await AssertThrowsAsync <TaskCanceledException>(task.AsTask()); }
public async Task ToAsyncEnumerable_Observable6_Async() { using var stop = new ManualResetEvent(false); var xs = new MyObservable <int>(obs => { var cts = new CancellationTokenSource(); Task.Run(async() => { for (var i = 0; !cts.IsCancellationRequested; i++) { await Task.Yield(); obs.OnNext(i); } stop.Set(); }); return(new MyDisposable(cts.Cancel)); }).ToAsyncEnumerable(); var e = xs.GetAsyncEnumerator(); for (var i = 0; i < 10_000; i++) { await HasNextAsync(e, i); } await e.DisposeAsync(); stop.WaitOne(); }
public virtual IObservable <string> ObserveContinuous(GetChangesRequest request, CancellationToken cancellationToken) { var httpRequest = ContinuousHttpRequestFactory.Create(request); var ob = new MyObservable <string>(); Task.Factory.StartNew(async() => { using (var httpResponse = await SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ForAwait()) { var response = await ContinuousChangesResponseFactory.CreateAsync(httpResponse).ForAwait(); if (response.IsSuccess) { using (var content = await httpResponse.Content.ReadAsStreamAsync().ForAwait()) { using (var reader = new StreamReader(content, MyCouchRuntime.DefaultEncoding)) { while (!cancellationToken.IsCancellationRequested && !reader.EndOfStream) { //cancellationToken.ThrowIfCancellationRequested(); if (!cancellationToken.IsCancellationRequested) { ob.Notify(reader.ReadLine()); } } ob.Complete(); } } } } }, cancellationToken).ForAwait(); return(ob); }
public void IObservable_Subscribe() { // Arrange var observable = new MyObservable(); var observer = new MyObserver(); // Act observable.Subscribe(observer); // Assert }
void Awake() { observable = new MyObservable(); Paused = false; castle = GameObject.FindGameObjectWithTag("Castle").GetComponent <Castle>(); spawner = GameObject.FindGameObjectWithTag("Spawner").GetComponent <Spawner>(); cam = GameObject.FindGameObjectWithTag("MainCamera"); }
void Awake() { Instance = this; PointerOverObjectChanged = new MyObservable(); mainMenuContext = transform.Find("MainMenu").gameObject; highscoresContext = transform.Find("Highscores").gameObject; instructionsContext = transform.Find("Instructions").gameObject; hud = transform.Find("HUD").gameObject; buildingTowerContext = hud.transform.Find("FourTowers").gameObject; selectedTowerContext = hud.transform.Find("SelectedTower").gameObject; gameOverContext = transform.Find("GameOverScreen").gameObject; gameOverName = gameOverContext.transform.Find("GameOverNameInputField").GetComponent <InputField>(); GameOverScoreText = gameOverContext.transform.Find("GameOverScoreText").GetComponent <Text>(); pauseMenuContext = transform.Find("PauseMenu").gameObject; ScoreText = hud.transform.Find("ScorePanel").Find("ScoreText").GetComponent <Text>(); GoldText = hud.transform.Find("LivesAndGoldPanel").Find("GoldNum").GetComponent <Text>(); LivesText = hud.transform.Find("LivesAndGoldPanel").Find("LivesNum").GetComponent <Text>(); detailsPanel = hud.transform.Find("DetailsPanel").gameObject; towerDetailsPanel = detailsPanel.transform.Find("TowerDetailsPanel").gameObject; critterDetailsPanel = detailsPanel.transform.Find("CritterDetailsPanel").gameObject; iconMap = new Dictionary <string, Sprite>(); for (int i = 0; i < iconKeys.Length; i++) { iconMap[iconKeys[i]] = iconVals[i]; } }
public void AutoDetachObserver_ImplementISafeObserver() { var myObserver = Observer.Create <int>(i => { i.Dump(); if (i == 1) { throw new Exception("triggered by observer"); } }, ex => ex.Message.ToString(), () => "completed".Dump()); var observer = new AutoDetachObserver <int>(myObserver); observer.SetResource(Disposable.Create(() => "obsrever exception i will clearnup by IDisposable Resource".Dump())); var observable = new MyObservable(); observable.Subscribe(observer); }
public void Update(MyObservable <Character> observed) { Character character = (Character)observed; if (character.CurrentHP <= 0) { if (character == Character) { state = BattleStates.LOSE; } else { if (Opponents.Where(i => i.CurrentHP > 0).ToList().Count == 0) { state = BattleStates.WIN; } } } }
public async Task ToAsyncEnumerable_Observable_Zip() { using var stop = new ManualResetEvent(false); var subCount = 0; var xs = new MyObservable <int>(obs => { subCount++; var cts = new CancellationTokenSource(); Task.Run(async() => { for (var i = 0; !cts.IsCancellationRequested; i++) { await Task.Delay(10); obs.OnNext(i); } stop.Set(); }); return(new MyDisposable(cts.Cancel)); }).ToAsyncEnumerable(); var e = xs.Zip(xs, (l, r) => l == r).GetAsyncEnumerator(); for (var i = 0; i < 10; i++) { await HasNextAsync(e, true); } await e.DisposeAsync(); stop.WaitOne(); Assert.Equal(2, subCount); }
public void ToAsyncEnumerable4() { var ex = new Exception("Bang!"); var subscribed = false; var xs = new MyObservable <int>(obs => { subscribed = true; obs.OnError(ex); return(new MyDisposable(() => { })); }).ToAsyncEnumerable(); Assert.False(subscribed); var e = xs.GetEnumerator(); Assert.True(subscribed); AssertThrows <Exception>(() => e.MoveNext().Wait(WaitTimeoutMs), ex_ => ((AggregateException)ex_).InnerExceptions.Single() == ex); }
public async Task ToAsyncEnumerable_Observable_Throw() { var ex = new Exception("Bang!"); var subscribed = false; var xs = new MyObservable <int>(obs => { subscribed = true; obs.OnError(ex); return(new MyDisposable(() => { })); }).ToAsyncEnumerable(); Assert.False(subscribed); var e = xs.GetAsyncEnumerator(); // NB: Breaking change to align with lazy nature of async iterators. // Assert.True(subscribed); await AssertThrowsAsync(e.MoveNextAsync(), ex); }
public void ToAsyncEnumerable3() { var subscribed = false; var xs = new MyObservable <int>(obs => { subscribed = true; obs.OnNext(42); obs.OnCompleted(); return(new MyDisposable(() => { })); }).ToAsyncEnumerable(); Assert.False(subscribed); var e = xs.GetEnumerator(); Assert.True(subscribed); HasNext(e, 42); NoNext(e); }
public async Task ToAsyncEnumerable_Observable_Return() { var subscribed = false; var xs = new MyObservable <int>(obs => { subscribed = true; obs.OnNext(42); obs.OnCompleted(); return(new MyDisposable(() => { })); }).ToAsyncEnumerable(); Assert.False(subscribed); var e = xs.GetAsyncEnumerator(); // NB: Breaking change to align with lazy nature of async iterators. // Assert.True(subscribed); await HasNextAsync(e, 42); await NoNextAsync(e); }
public void UnitObserveable_ctor() { var ob = new MyObservable(); }
void Awake() { observable = new MyObservable(); cam = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <Camera>(); }
void Awake() { observable = new MyObservable(); }
protected virtual void Awake() { KillPending = false; observable = new MyObservable(); }