| public static SendStartCoroutine ( IEnumerator routine ) : void | ||
| routine | IEnumerator | |
| return | void | |
public IDisposable SchedulePeriodic(TimeSpan period, Action action)
{
var d = new BooleanDisposable();
var time = Scheduler.Normalize(period);
MainThreadDispatcher.SendStartCoroutine(PeriodicAction(time, action, d));
return(d);
}
public IDisposable Schedule(TimeSpan dueTime, Action action)
{
var d = new BooleanDisposable();
var time = Scheduler.Normalize(dueTime);
MainThreadDispatcher.SendStartCoroutine(DelayAction(time, action, d));
return(d);
}
public static IObservable <T> FromCoroutine <T>(Func <IObserver <T>, CancellationToken, IEnumerator> coroutine)
{
return(Observable.Create <T>(observer =>
{
var cancel = new BooleanDisposable();
MainThreadDispatcher.SendStartCoroutine(coroutine(observer, new CancellationToken(cancel)));
return cancel;
}));
}
public IDisposable Schedule(TimeSpan dueTime, Action action)
{
BooleanDisposable d = new BooleanDisposable();
TimeSpan dueTime2 = Normalize(dueTime);
MainThreadDispatcher.SendStartCoroutine(DelayAction(dueTime2, delegate
{
if (!d.IsDisposed)
{
action();
}
}, d));
return(d);
}
protected override IDisposable SubscribeCore(IObserver <T> observer, IDisposable cancel)
{
var fromCoroutineObserver = new FromCoroutine(observer, cancel);
#if (NETFX_CORE || NET_4_6 || NET_STANDARD_2_0 || UNITY_WSA_10_0)
var moreCancel = new CancellationDisposable();
var token = moreCancel.Token;
#else
var moreCancel = new BooleanDisposable();
var token = new CancellationToken(moreCancel);
#endif
MainThreadDispatcher.SendStartCoroutine(coroutine(fromCoroutineObserver, token));
return(moreCancel);
}
static IObservable <T> RepeatUntilCore <T>(this IEnumerable <IObservable <T> > sources, IObservable <Unit> trigger, GameObject lifeTimeChecker)
{
return(Observable.Create <T>(observer =>
{
var isFirstSubscribe = true;
var isDisposed = false;
var isStopped = false;
var e = sources.AsSafeEnumerable().GetEnumerator();
var subscription = new SerialDisposable();
var schedule = new SingleAssignmentDisposable();
var gate = new object();
var stopper = trigger.Subscribe(_ =>
{
lock (gate)
{
isStopped = true;
e.Dispose();
subscription.Dispose();
schedule.Dispose();
observer.OnCompleted();
}
}, observer.OnError);
schedule.Disposable = Scheduler.CurrentThread.Schedule(self =>
{
lock (gate)
{
if (isDisposed)
{
return;
}
if (isStopped)
{
return;
}
var current = default(IObservable <T>);
var hasNext = false;
var ex = default(Exception);
try
{
hasNext = e.MoveNext();
if (hasNext)
{
current = e.Current;
if (current == null)
{
throw new InvalidOperationException("sequence is null.");
}
}
else
{
e.Dispose();
}
}
catch (Exception exception)
{
ex = exception;
e.Dispose();
}
if (ex != null)
{
stopper.Dispose();
observer.OnError(ex);
return;
}
if (!hasNext)
{
stopper.Dispose();
observer.OnCompleted();
return;
}
var source = e.Current;
var d = new SingleAssignmentDisposable();
subscription.Disposable = d;
var repeatObserver = Observer.Create <T>(observer.OnNext, observer.OnError, self);
if (isFirstSubscribe)
{
isFirstSubscribe = false;
d.Disposable = source.Subscribe(repeatObserver);
}
else
{
MainThreadDispatcher.SendStartCoroutine(SubscribeAfterEndOfFrame(d, source, repeatObserver, lifeTimeChecker));
}
}
});
return new CompositeDisposable(schedule, subscription, stopper, Disposable.Create(() =>
{
lock (gate)
{
isDisposed = true;
e.Dispose();
}
}));
}));
}
