public ReplayAsyncSubject(bool concurrent, TimeSpan window)
{
if (window < TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException(nameof(window));
}
_impl = new ReplayTime(concurrent, ImmediateAsyncScheduler.Instance, int.MaxValue, window, CreateImmediateObserver);
}
public ReplayAsyncSubject(bool concurrent, TimeSpan window, IAsyncScheduler scheduler)
{
if (window < TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException(nameof(window));
}
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
_impl = new ReplayTime(concurrent, scheduler, int.MaxValue, window, o => CreateScheduledObserver(o, scheduler));
}
public ReplayAsyncSubject(bool concurrent, int bufferSize)
{
if (bufferSize < 0)
{
throw new ArgumentOutOfRangeException(nameof(bufferSize));
}
if (bufferSize == 1)
{
_impl = new ReplayOne(concurrent, CreateImmediateObserver);
}
else if (bufferSize == int.MaxValue)
{
_impl = new ReplayAll(concurrent, CreateImmediateObserver);
}
else
{
_impl = new ReplayMany(concurrent, CreateImmediateObserver, bufferSize);
}
}
public ReplayAsyncSubject(bool concurrent, int bufferSize, IAsyncScheduler scheduler)
{
if (bufferSize < 0)
{
throw new ArgumentOutOfRangeException(nameof(bufferSize));
}
if (scheduler == null)
{
throw new ArgumentNullException(nameof(scheduler));
}
if (bufferSize == 1)
{
_impl = new ReplayOne(concurrent, o => CreateScheduledObserver(o, scheduler));
}
else if (bufferSize == int.MaxValue)
{
_impl = new ReplayAll(concurrent, o => CreateScheduledObserver(o, scheduler));
}
else
{
_impl = new ReplayMany(concurrent, o => CreateScheduledObserver(o, scheduler), bufferSize);
}
}
public ConnectableAsyncObservable(IAsyncObservable <TSource> source, IAsyncSubject <TSource, TResult> subject)
{
this.subject = subject;
this.source = source.AsAsyncObservable();
}
public WindowAsyncObservable(IAsyncSubject <TSource> subject, RefCountAsyncDisposable disposable)
{
_subject = subject;
_disposable = disposable;
}
public GroupedAsyncObservable(TKey key, IAsyncSubject <TElement> subject, RefCountAsyncDisposable disposable)
{
Key = key;
_subject = subject;
_disposable = disposable;
}
public static IConnectableAsyncObservable <TResult> Multicast <TSource, TResult>(this IAsyncObservable <TSource> source, IAsyncSubject <TSource, TResult> subject)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (subject == null)
{
throw new ArgumentNullException(nameof(subject));
}
return(new ConnectableAsyncObservable <TSource, TResult>(source, subject));
}
