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); }