public void FutureDisposable_DisposeAfterSet()
{
var disposed = false;
var d = new MutableDisposable();
var dd = Disposable.Create(() => { disposed = true; });
d.Disposable = dd;
Assert.AreSame(dd, d.Disposable);
Assert.IsFalse(disposed);
d.Dispose();
Assert.IsTrue(disposed);
d.Dispose();
Assert.IsTrue(disposed);
}
public void Dispose()
{
if (!isDisposed)
{
isDisposed = true;
subscription.Dispose();
}
}
public void FutureDisposable_DisposeBeforeSet()
{
var disposed = false;
var d = new MutableDisposable();
var dd = Disposable.Create(() => { disposed = true; });
Assert.IsFalse(disposed);
d.Dispose();
Assert.IsFalse(disposed);
d.Disposable = dd;
Assert.IsNull(d.Disposable); // CHECK!
Assert.IsTrue(disposed);
d.Dispose();
Assert.IsTrue(disposed);
}
public void MutableDisposable_Dispose()
{
var disp = false;
var m = new MutableDisposable();
var d = Disposable.Create(() => { disp = true; });
m.Disposable = d;
Assert.AreSame(d, m.Disposable);
Assert.IsFalse(disp);
m.Dispose();
Assert.IsTrue(disp);
Assert.IsNull(m.Disposable);
}
public void MutableDisposable_ReplaceAfterDispose()
{
var disp1 = false;
var disp2 = false;
var m = new MutableDisposable();
m.Dispose();
var d1 = Disposable.Create(() => { disp1 = true; });
m.Disposable = d1;
Assert.IsNull(m.Disposable); // CHECK
Assert.IsTrue(disp1);
var d2 = Disposable.Create(() => { disp2 = true; });
m.Disposable = d2;
Assert.IsNull(m.Disposable); // CHECK
Assert.IsTrue(disp2);
}
public void Dispose()
{
_disposable.Dispose();
}
/// <summary>
/// Transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.
/// </summary>
public static IObservable <TSource> Switch <TSource>(this IObservable <IObservable <TSource> > source)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
return(new AnonymousObservable <TSource>(observer =>
{
var gate = new object();
var innerSubscription = new MutableDisposable();
var subscription = new MutableDisposable();
var isStopped = false;
subscription.Disposable = source.Subscribe(
innerSource =>
{
var d = new MutableDisposable();
innerSubscription.Disposable = d;
d.Disposable = innerSource.Subscribe(
x =>
{
lock (gate)
observer.OnNext(x);
},
exception =>
{
subscription.Dispose();
innerSubscription.Dispose();
lock (gate)
observer.OnError(exception);
},
() =>
{
innerSubscription.Disposable = null;
if (isStopped)
{
lock (gate)
observer.OnCompleted();
}
});
},
exception =>
{
innerSubscription.Dispose();
lock (gate)
observer.OnError(exception);
},
() =>
{
isStopped = true;
if (innerSubscription.Disposable == null)
{
lock (gate)
observer.OnCompleted();
}
});
return new CompositeDisposable(subscription, innerSubscription);
}));
}
/// <summary>
/// Ignores values from an observable sequence which are followed by another value before dueTime.
/// </summary>
public static IObservable <TSource> Throttle <TSource>(this IObservable <TSource> source, TimeSpan dueTime, IScheduler scheduler)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (scheduler == null)
{
throw new ArgumentNullException("scheduler");
}
return(new AnonymousObservable <TSource>(observer =>
{
var gate = new object();
var value = default(TSource);
var hasValue = false;
var cancelable = new MutableDisposable();
var id = 0UL;
var subscription = source.Subscribe(x =>
{
ulong currentid;
lock (gate)
{
hasValue = true;
value = x;
id = unchecked (id + 1);
currentid = id;
}
var d = new MutableDisposable();
cancelable.Disposable = d;
d.Disposable = scheduler.Schedule(() =>
{
lock (gate)
{
if (hasValue && id == currentid)
{
observer.OnNext(value);
}
hasValue = false;
}
}, dueTime);
},
exception =>
{
cancelable.Dispose();
lock (gate)
{
observer.OnError(exception);
hasValue = false;
id = unchecked (id + 1);
}
},
() =>
{
cancelable.Dispose();
lock (gate)
{
if (hasValue)
{
observer.OnNext(value);
}
observer.OnCompleted();
hasValue = false;
id = unchecked (id + 1);
}
});
return new CompositeDisposable(subscription, cancelable);
}));
}
