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();
}
