public static IDisposable HandleClients(TcpListener listener, Func<TcpClient, string, Task> handleClientAccessPolicy, string policyResponse) { listener.Start(); var disposableHandler = ThreadPoolScheduler.Instance.ScheduleAsync(async (scheduler, ct) => { var disposable = new BooleanDisposable(); while (!disposable.IsDisposed) { var client = await listener.AcceptTcpClientAsync(); await handleClientAccessPolicy(client, policyResponse); await scheduler.Yield(); } return disposable; }); var compositeDisposable = new CompositeDisposable(); compositeDisposable.Add(Disposable.Create(() => listener.Stop())); compositeDisposable.Add(disposableHandler); return compositeDisposable; }
/// <summary> /// note: below test demonstrate "Take" will notify its observer to complete /// and unsubscribe from its source observable /// below two tests the generation of the source will be interrupted /// it won't generate "totol" items, but only "expected" items /// Take, like all the other operators, just subscribe on its source observable /// and keep the "IDisposable" returned, after enough items have been collected /// it will call Dispose on that IDisposable to unsubscribe from its source /// and then the generation will stoped (OTHER THAN the case that source will /// generate all, and only some are delivered to the observer). THE ACTUAL CASE is /// the source will generate, and only generate, those expected ones and then /// be interrupted and stop /// ********************* ONE EXECUTION RESULTS IS LIKE: /// producing <0>,...... /// [0] consumed. /// producing <1>,...... /// [1] consumed. /// consumption is totally completed. /// !!! production is interrupted. /// production completes. /// chekanote: pay attention that, "consumer" exits earlier than "producer" /// so it is the Take operator to notify the observer to complete /// not the "completion" propagated from the original source /// </summary> private static void TestBoolDisposable(int total, int expected) { IObservable<int> source = Observable.Create<int>(observer => { BooleanDisposable disposable = new BooleanDisposable(); Task.Factory.StartNew(() => { for (int index = 0; index < total; index++) { if (disposable.IsDisposed) { Console.WriteLine("!!! production is interrupted."); break; } else { observer.Consume(index); } } observer.OnCompleted(); Console.WriteLine("production completes."); });// start task return disposable; }); source.ConsumeSome(expected); Helper.Pause(); }
public void SelectDisposableShouldWork() { var scheduler = new TestScheduler(); var disposables = new List<BooleanDisposable>(); var list = new CompositeDisposable(); scheduler.CreateColdObservable( new Recorded<Notification<long>>(100, Notification.CreateOnNext(0L)), new Recorded<Notification<long>>(200, Notification.CreateOnNext(1L)), new Recorded<Notification<long>>(300, Notification.CreateOnNext(2L)), new Recorded<Notification<long>>(400, Notification.CreateOnNext(3L)), new Recorded<Notification<long>>(400, Notification.CreateOnCompleted<long>()) ) .SelectDisposable(list, i => { var d = new BooleanDisposable(); disposables.Add(d); return d; }, (i, _) => i) .Subscribe() .DisposeWith(list); scheduler.AdvanceTo(300); disposables.Count.Should().Be(3); disposables.Select(d => d.IsDisposed).Should().NotContain(true); list.Dispose(); disposables.Select(d => d.IsDisposed).Should().NotContain(false); }
public void BooleanDisposable() { var d = new BooleanDisposable(); Assert.IsFalse(d.IsDisposed); d.Dispose(); Assert.IsTrue(d.IsDisposed); d.Dispose(); Assert.IsTrue(d.IsDisposed); }
private static void BooleanDisposable() { Demo.DisplayHeader("The BooleanDispoable - sets a boolean flag upon disposal"); var booleanDisposable = new BooleanDisposable(); Console.WriteLine("Before dispose, booleanDisposable.IsDisposed = {0}", booleanDisposable.IsDisposed); booleanDisposable.Dispose(); Console.WriteLine("After dispose, booleanDisposable.IsDisposed = {0}", booleanDisposable.IsDisposed); }
public IDisposable Schedule(Action action) { var d = new BooleanDisposable(); System.Threading.ThreadPool.QueueUserWorkItem(_ => { if (!d.IsDisposed) { action(); } }); return d; }
public static IObservable<Tuple<IDisposable<byte[]>, int>> ReadAsync(this Stream stream, int bufferSize, bool waitForObserver, bool refCount, IProducerConsumerCollection<IDisposable<byte[]>> cache) { var read = Observable.FromAsyncPattern<byte[], int, int, int> (stream.BeginRead, stream.EndRead); return Observable.Create<Tuple<IDisposable<byte[]>, int>> (observer => { var subscription = new BooleanDisposable (); Action<Exception> onError = error => { observer.OnError (error); subscription.Dispose (); }; Action loop = null; Action<IDisposable<byte[]>, int> engine; if (waitForObserver) engine = (buffer, bytesRead) => { // OnNext is called first observer.OnNext (new Tuple<IDisposable<byte[]>, int> (buffer, bytesRead)); // then we begin async read if (!subscription.IsDisposed) loop (); }; else engine = (buffer, bytesRead) => { // begin async read first if (!subscription.IsDisposed) loop (); //then call OnNext observer.OnNext (new Tuple<IDisposable<byte[]>, int> (buffer, bytesRead)); }; loop = () => { var buffer = cache.TakeOrCreate (refCount, () => new byte[bufferSize]); read (buffer.Value, 0, bufferSize).Subscribe (bytesRead => { if (0 == bytesRead) observer.OnCompleted (); else engine (buffer, bytesRead); }, onError); }; loop (); return subscription; }); }
private static IObservable<string> GetLines(this WebResponse response) { return Observable.Create<string>(obs => { var disposable = new BooleanDisposable(); var stream = response.GetResponseStream(); var reader = Observable.FromAsyncPattern<byte[], int, int, int>(stream.BeginRead, stream.EndRead); try { var buffer = new byte[256]; int count; var sb = new StringBuilder(); while (!disposable.IsDisposed && (count = reader(buffer, 0, buffer.Length).First()) > 0) { for (int i = 0; i < count; i++) { var c = (char)buffer[i]; sb.Append(c); if (c == '\n' && sb.Length > 0) { obs.OnNext(sb.ToString()); sb.Clear(); } } } if (sb.Length > 0) { obs.OnNext(sb.ToString()); } } catch (Exception e) { obs.OnError(e); } finally { obs.OnCompleted(); response.Dispose(); } return disposable; }); }
public void RefCountDisposable_PrimaryDisposesFirst() { var d = new BooleanDisposable(); var r = new RefCountDisposable(d); Assert.IsFalse(d.IsDisposed); var d1 = r.GetDisposable(); var d2 = r.GetDisposable(); Assert.IsFalse(d.IsDisposed); d1.Dispose(); Assert.IsFalse(d.IsDisposed); r.Dispose(); Assert.IsFalse(d.IsDisposed); d2.Dispose(); Assert.IsTrue(d.IsDisposed); }
public void RefCountDisposable_RefCounting() { var d = new BooleanDisposable(); var r = new RefCountDisposable(d); Assert.IsFalse(d.IsDisposed); var d1 = r.GetDisposable(); var d2 = r.GetDisposable(); Assert.IsFalse(d.IsDisposed); d1.Dispose(); Assert.IsFalse(d.IsDisposed); d2.Dispose(); Assert.IsFalse(d.IsDisposed); // CHECK r.Dispose(); Assert.IsTrue(d.IsDisposed); Assert.IsTrue(r.IsDisposed); var d3 = r.GetDisposable(); // CHECK d3.Dispose(); }
public void RefCountDisposable_SingleReference() { var d = new BooleanDisposable(); var r = new RefCountDisposable(d); Assert.IsFalse(d.IsDisposed); r.Dispose(); Assert.IsTrue(d.IsDisposed); r.Dispose(); Assert.IsTrue(d.IsDisposed); }
public MessageToken() { Cancellation = new CancellationDisposable(); InErrorState = new BooleanDisposable(); }
public void Background_tasks_that_return_disposables_have_their_disposables_disposed_with_the_Configuration() { var configuration = new Configuration(); var disposable = new BooleanDisposable(); configuration.QueueBackgroundWork(c => disposable); configuration.StartBackgroundWork(); disposable.IsDisposed.Should().BeFalse(); configuration.Dispose(); disposable.IsDisposed.Should().BeTrue(); }
public void CreateWithDisposable_Dispose() { var scheduler = new TestScheduler(); var res = scheduler.Start(() => Observable.Create<int>(o => { var d = new BooleanDisposable(); o.OnNext(1); o.OnNext(2); scheduler.Schedule(TimeSpan.FromTicks(600), () => { if (!d.IsDisposed) o.OnNext(3); }); scheduler.Schedule(TimeSpan.FromTicks(700), () => { if (!d.IsDisposed) o.OnNext(4); }); scheduler.Schedule(TimeSpan.FromTicks(900), () => { if (!d.IsDisposed) o.OnNext(5); }); scheduler.Schedule(TimeSpan.FromTicks(1100), () => { if (!d.IsDisposed) o.OnNext(6); }); return d; }) ); res.Messages.AssertEqual( OnNext(200, 1), OnNext(200, 2), OnNext(800, 3), OnNext(900, 4) ); }
public void ScheduledDisposable() { var d = new BooleanDisposable(); var s = new ScheduledDisposable(Scheduler.Immediate, d); Assert.IsFalse(d.IsDisposed); Assert.AreSame(Scheduler.Immediate, s.Scheduler); Assert.AreSame(d, s.Disposable); s.Dispose(); Assert.IsTrue(d.IsDisposed); Assert.IsTrue(s.IsDisposed); Assert.AreSame(Scheduler.Immediate, s.Scheduler); //Assert.AreSame(d, s.Disposable); // BREAKING CHANGE v2 > v1.x - Undefined behavior after disposal. s.Disposable.Dispose(); // This should be a nop. }
public void Boolean() { var bd = new BooleanDisposable(); bd.IsDisposed.IsFalse(); bd.Dispose(); bd.IsDisposed.IsTrue(); }
public void RegisterForDisposal_can_be_used_to_specify_objects_that_should_be_disposed_when_the_Configuration_is_disposed() { var disposable = new BooleanDisposable(); var configuration = new Configuration(); configuration.RegisterForDisposal(disposable); disposable.IsDisposed.Should().BeFalse(); configuration.Dispose(); disposable.IsDisposed.Should().BeTrue(); }