public IDisposable Schedule(TimeSpan dueTime, Action action)
{
var d = new BooleanDisposable();
var time = Scheduler.Normalize(dueTime);
MainThreadDispatcher.StartEndOfFrameMicroCoroutine(DelayAction(time, action, d));
return(d);
}
public IDisposable SchedulePeriodic(TimeSpan period, Action action)
{
var d = new BooleanDisposable();
var time = Scheduler.Normalize(period);
MainThreadDispatcher.StartEndOfFrameMicroCoroutine(PeriodicAction(time, action, d));
return(d);
}
public IDisposable Schedule <TState>(TState state, TimeSpan dueTime, Func <IScheduler, TState, IDisposable> action)
{
var wait = Scheduler.Normalize(dueTime);
if (wait.Ticks > 0)
{
Thread.Sleep(wait);
}
return(action(this, state));
}
public IDisposable Schedule(TimeSpan dueTime, Action action)
{
TimeSpan timeSpan = Scheduler.Normalize(dueTime);
if (timeSpan.get_Ticks() > 0L)
{
Thread.Sleep(timeSpan);
}
action.Invoke();
return(Disposable.Empty);
}
public IDisposable Schedule(TimeSpan dueTime, Action action)
{
TimeSpan timeout = Scheduler.Normalize(dueTime);
if (timeout.Ticks > 0L)
{
Thread.Sleep(timeout);
}
action();
return(Disposable.Empty);
}
public IDisposable Schedule(TimeSpan dueTime, Action action)
{
var wait = Scheduler.Normalize(dueTime);
if (wait.Ticks > 0)
{
Thread.Sleep(wait);
}
action();
return(Disposable.Empty);
}
void Trim()
{
var elapsedTime = Scheduler.Normalize(scheduler.Now - startTime);
while (queue.Count > bufferSize)
{
queue.Dequeue();
}
while (queue.Count > 0 && elapsedTime.Subtract(queue.Peek().Interval).CompareTo(window) > 0)
{
queue.Dequeue();
}
}
private void Trim()
{
TimeSpan timeSpan = Scheduler.Normalize(this.scheduler.Now - this.startTime);
while (this.queue.get_Count() > this.bufferSize)
{
this.queue.Dequeue();
}
while (this.queue.get_Count() > 0 && timeSpan.Subtract(this.queue.Peek().Interval).CompareTo(this.window) > 0)
{
this.queue.Dequeue();
}
}
static IObservable <long> TimerCore(TimeSpan dueTime, IScheduler scheduler)
{
var time = Scheduler.Normalize(dueTime);
return(Observable.Create <long>(observer =>
{
return scheduler.Schedule(time, self =>
{
observer.OnNext(0);
observer.OnCompleted();
});
}));
}
private void Trim()
{
TimeSpan timeSpan = Scheduler.Normalize(scheduler.Now - startTime);
while (queue.Count > bufferSize)
{
queue.Dequeue();
}
while (queue.Count > 0 && timeSpan.Subtract(queue.Peek().Interval).CompareTo(window) > 0)
{
queue.Dequeue();
}
}
public IDisposable Schedule <TState>(TState state, DateTimeOffset dueTime, Func <IScheduler, TState, IDisposable> action)
{
var queue = threadStaticQueue;
if (queue == null)
{
queue = threadStaticQueue = new SchedulingPriorityQueue();
}
if (queue.Count > 0)
{
var d = new SingleAssignmentDisposable();
queue.Enqueue(() =>
{
if (!d.IsDisposed)
{
d.Disposable = action(this, state);
}
}, dueTime, d);
return(d);
}
var rootCancel = new BooleanDisposable();
queue.Enqueue(() => action(this, state), dueTime, rootCancel);
while (queue.Count > 0)
{
Action act;
DateTimeOffset dt;
ICancelable cancel;
using (queue.Dequeue(out act, out dt, out cancel))
{
if (!cancel.IsDisposed)
{
var wait = Scheduler.Normalize(dt - Now);
if (wait.Ticks > 0)
{
Thread.Sleep(wait);
}
act();
}
}
}
threadStaticQueue = null;
return(rootCancel);
}
public IDisposable Schedule(TimeSpan dueTime, Action action)
{
var d = new BooleanDisposable();
var time = Scheduler.Normalize(dueTime);
MainThreadDispatcher.SendStartCoroutine(DelayAction(time, () =>
{
if (!d.IsDisposed)
{
action();
}
}, d));
return(d);
}
public static IObservable <T> DelaySubscription <T>(this IObservable <T> source, TimeSpan dueTime, IScheduler scheduler)
{
return(Observable.Create <T>(observer =>
{
var d = new MultipleAssignmentDisposable();
var dt = Scheduler.Normalize(dueTime);
d.Disposable = scheduler.Schedule(dt, () =>
{
d.Disposable = source.Subscribe(observer);
});
return d;
}));
}
static IObservable <long> TimerCore(TimeSpan dueTime, TimeSpan period, IScheduler scheduler)
{
var timeD = Scheduler.Normalize(dueTime);
var timeP = Scheduler.Normalize(period);
return(Observable.Create <long>(observer =>
{
var count = 0;
return scheduler.Schedule(timeD, self =>
{
observer.OnNext(count);
count++;
self(timeP);
});
}));
}
public IDisposable Schedule(TimeSpan dueTime, Action action)
{
var wait = Scheduler.Normalize(dueTime);
var d = new BooleanDisposable();
#if NETFX_CORE
Task.Run(()=>
{
if (!d.IsDisposed)
{
if (wait.Ticks > 0)
{
Thread.Sleep(wait);
}
action();
}
});
#else
Action act = () =>
{
if (!d.IsDisposed)
{
if (wait.Ticks > 0)
{
Thread.Sleep(wait);
}
action();
}
};
act.BeginInvoke(ar => act.EndInvoke(ar), null);
#endif
return d;
}
public IDisposable Schedule(TimeSpan dueTime, Action action)
{
var wait = Scheduler.Normalize(dueTime);
var d = new BooleanDisposable();
Action act = () =>
{
if (!d.IsDisposed)
{
if (wait.Ticks > 0)
{
Thread.Sleep(wait);
}
action();
}
};
act.BeginInvoke(ar => act.EndInvoke(ar), null);
return(d);
}
public IDisposable Schedule(TimeSpan dueTime, Action action)
{
if (action == null)
{
throw new ArgumentNullException("action");
}
var dt = Time + Scheduler.Normalize(dueTime);
var si = new ScheduledItem(action, dt);
var queue = GetQueue();
//加入队列执行
if (queue == null)
{
queue = new SchedulerQueue(4);
queue.Enqueue(si);
CurrentThreadScheduler.SetQueue(queue);
try
{
Trampoline.Run(queue);
}
finally
{
CurrentThreadScheduler.SetQueue(null);
}
}
else
{
queue.Enqueue(si);
}
return(si.Cancellation);
}
public IDisposable Schedule(TimeSpan dueTime, Action action)
{
if (action == null)
{
throw new ArgumentNullException("action");
}
TimeSpan dueTime2 = Scheduler.CurrentThreadScheduler.Time + Scheduler.Normalize(dueTime);
ScheduledItem scheduledItem = new ScheduledItem(action, dueTime2);
SchedulerQueue schedulerQueue = Scheduler.CurrentThreadScheduler.GetQueue();
if (schedulerQueue == null)
{
schedulerQueue = new SchedulerQueue(4);
schedulerQueue.Enqueue(scheduledItem);
Scheduler.CurrentThreadScheduler.SetQueue(schedulerQueue);
try
{
Scheduler.CurrentThreadScheduler.Trampoline.Run(schedulerQueue);
}
finally
{
Scheduler.CurrentThreadScheduler.SetQueue(null);
}
}
else
{
schedulerQueue.Enqueue(scheduledItem);
}
return(scheduledItem.Cancellation);
}