public void Concurrent()
{
var overlapping = new AnonymousObservable<Task<int>>(observer => {
var n = 6;
var r = n;
for (var i = 0; i < n; i++)
new Thread(() => {
observer.OnNext(Task.FromResult(0));
if (Interlocked.Decrement(ref r) == 0)
observer.OnCompleted();
}).Start();
return Disposable.Empty;
});
var overlapCount = 0;
var t = new TaskCompletionSource<bool>();
overlapping
.WhenEach()
.Subscribe(e => {
if (Interlocked.Increment(ref overlapCount) > 4)
t.TrySetResult(true);
t.Task.AssertRanToCompletion();
});
t.Task.AssertRanToCompletion();
}
public void Concurrent()
{
var overlapping = new AnonymousObservable <Task <int> >(observer => {
var n = 6;
var r = n;
for (var i = 0; i < n; i++)
{
new Thread(() => {
observer.OnNext(Task.FromResult(0));
if (Interlocked.Decrement(ref r) == 0)
{
observer.OnCompleted();
}
}).Start();
}
return(Disposable.Empty);
});
var overlapCount = 0;
var t = new TaskCompletionSource <bool>();
overlapping
.WhenEach()
.Subscribe(e => {
if (Interlocked.Increment(ref overlapCount) > 4)
{
t.TrySetResult(true);
}
t.Task.AssertRanToCompletion();
});
t.Task.AssertRanToCompletion();
}
public void WorksWithoutCompletion()
{
var hang = new AnonymousObservable <Task <int> >(obs => Disposable.Empty);
var r = 1.Range()
.Select(Task.FromResult)
.ToObservable()
.Concat(hang)
.WhenEach()
.ObserveEventualIntoList();
r[0].AssertRanToCompletion().AssertRanToCompletion().AssertEquals(0);
r[1].AssertNotCompleted();
}
private static IObservable <TEventArgs> FromEvent_ <TDelegate, TEventArgs>(Func <Action <TEventArgs>, TDelegate> conversion, Action <TDelegate> addHandler, Action <TDelegate> removeHandler, IScheduler scheduler)
{
#if !NO_PERF
return(new FromEvent <TDelegate, TEventArgs>(conversion, addHandler, removeHandler, scheduler));
#else
var res = new AnonymousObservable <TEventArgs>(observer =>
{
var handler = conversion(observer.OnNext);
addHandler(handler);
return(Disposable.Create(() => removeHandler(handler)));
});
return(SynchronizeEvents(res, scheduler));
#endif
}
private static IObservable <TEventArgs> FromEvent_ <TDelegate, TEventArgs>(Action <TDelegate> addHandler, Action <TDelegate> removeHandler, IScheduler scheduler)
{
#if !NO_PERF
return(new FromEvent <TDelegate, TEventArgs>(addHandler, removeHandler, scheduler));
#else
var res = new AnonymousObservable <TEventArgs>(observer =>
{
Action <TEventArgs> handler = observer.OnNext;
var d = ReflectionUtils.CreateDelegate <TDelegate>(handler, typeof(Action <TEventArgs>).GetMethod("Invoke"));
addHandler(d);
return(Disposable.Create(() => removeHandler(d)));
});
return(SynchronizeEvents(res, scheduler));
#endif
}
private static IObservable <EventPattern <TEventArgs> > FromEventPattern_ <TDelegate, TEventArgs>(Func <EventHandler <TEventArgs>, TDelegate> conversion, Action <TDelegate> addHandler, Action <TDelegate> removeHandler, IScheduler scheduler)
#endif
{
#if !NO_PERF
return(new FromEventPattern.Impl <TDelegate, TEventArgs>(conversion, addHandler, removeHandler, scheduler));
#else
var res = new AnonymousObservable <EventPattern <TEventArgs> >(observer =>
{
var handler = conversion((sender, eventArgs) => observer.OnNext(new EventPattern <TEventArgs>(sender, eventArgs)));
addHandler(handler);
return(Disposable.Create(() => removeHandler(handler)));
});
return(SynchronizeEvents(res, scheduler));
#endif
}
private static IObservable <TResult> FromEventPattern_ <TSender, TEventArgs, TResult>(Type targetType, object target, string eventName, Func <TSender, TEventArgs, TResult> getResult, IScheduler scheduler)
#if !NO_EVENTARGS_CONSTRAINT
where TEventArgs : EventArgs
#endif
{
var addMethod = default(MethodInfo);
var removeMethod = default(MethodInfo);
var delegateType = default(Type);
var isWinRT = default(bool);
ReflectionUtils.GetEventMethods <TSender, TEventArgs>(targetType, target, eventName, out addMethod, out removeMethod, out delegateType, out isWinRT);
#if HAS_WINRT
if (isWinRT)
{
#if !NO_PERF
return(new FromEventPattern.ρ <TSender, TEventArgs, TResult>(target, delegateType, addMethod, removeMethod, getResult, true, scheduler));
#else
return(new AnonymousObservable <TResult>(observer =>
{
Action <TSender, TEventArgs> handler = (sender, eventArgs) => observer.OnNext(getResult(sender, eventArgs));
var d = ReflectionUtils.CreateDelegate(delegateType, handler, typeof(Action <TSender, TEventArgs>).GetMethod("Invoke"));
var token = addMethod.Invoke(target, new object[] { d });
return Disposable.Create(() => removeMethod.Invoke(target, new object[] { token }));
}));
#endif
}
#endif
#if !NO_PERF
return(new FromEventPattern.ρ <TSender, TEventArgs, TResult>(target, delegateType, addMethod, removeMethod, getResult, false, scheduler));
#else
var res = new AnonymousObservable <TResult>(observer =>
{
Action <TSender, TEventArgs> handler = (sender, eventArgs) => observer.OnNext(getResult(sender, eventArgs));
var d = ReflectionUtils.CreateDelegate(delegateType, handler, typeof(Action <TSender, TEventArgs>).GetMethod("Invoke"));
addMethod.Invoke(target, new object[] { d });
return(Disposable.Create(() => removeMethod.Invoke(target, new object[] { d })));
});
return(SynchronizeEvents(res, scheduler));
#endif
}
public WeatherService(TimeRange updateInterval)
{
_updateInterval = updateInterval;
_current = GetNextWeather();
_observable = AnonymousObservable <Packet> .Create(OnSubscribe);
}
public void WorksWithoutCompletion()
{
var hang = new AnonymousObservable<Task<int>>(obs => Disposable.Empty);
var r = 1.Range()
.Select(Task.FromResult)
.ToObservable()
.Concat(hang)
.WhenEach()
.ObserveEventualIntoList();
r[0].AssertRanToCompletion().AssertRanToCompletion().AssertEquals(0);
r[1].AssertNotCompleted();
}
