private void DownHeap(int pos)
{
int current = pos;
int child = 2 * current + 1;
while (child < size && size > 0)
{
// compare the children if they exist
if (child + 1 < size && timers[child + 1].when < timers[child].when)
{
child++;
}
// compare selected child with parent
if (timers[current].when < timers[child].when)
{
break;
}
// swap the two
TimerTask tmp = timers[current];
timers[current] = timers[child];
timers[child] = tmp;
// update pos and current
current = child;
child = 2 * current + 1;
}
}
/// <summary>
/// Schedules the specified TimerTask for repeated fixed-rate execution, beginning
/// after the specified delay. Subsequent executions take place at approximately regular
/// intervals, separated by the specified period.
///
/// In fixed-rate execution, each execution is scheduled relative to the scheduled execution
/// time of the initial execution. If an execution is delayed for any reason (such as garbage
/// collection or other background activity), two or more executions will occur in rapid
/// succession to "catch up."
///
/// Fixed-rate execution is appropriate for recurring activities that are sensitive to
/// absolute time, such as ringing a chime every hour on the hour, or running scheduled
/// maintenance every day at a particular time.
/// </summary>
public void ScheduleAtFixedRate(TimerTask task, TimeSpan delay, TimeSpan period)
{
if (delay.CompareTo(TimeSpan.Zero) < 0 || period.CompareTo(TimeSpan.Zero) <= 0)
{
throw new ArgumentOutOfRangeException();
}
DoScheduleImpl(task, delay, period, true);
}
/// <summary>
/// Schedules the specified TimerTask for execution after the specified delay.
/// </summary>
public void Schedule(TimerTask task, TimeSpan delay)
{
if (delay.CompareTo(TimeSpan.Zero) < 0)
{
throw new ArgumentOutOfRangeException();
}
DoScheduleImpl(task, delay, TimeSpan.FromMilliseconds(-1), false);
}
/// <summary>
/// Schedules the specified TimerTask for repeated fixed-rate execution, beginning
/// after the specified delay. Subsequent executions take place at approximately regular
/// intervals, separated by the specified period.
///
/// In fixed-rate execution, each execution is scheduled relative to the scheduled execution
/// time of the initial execution. If an execution is delayed for any reason (such as garbage
/// collection or other background activity), two or more executions will occur in rapid
/// succession to "catch up."
///
/// Fixed-rate execution is appropriate for recurring activities that are sensitive to
/// absolute time, such as ringing a chime every hour on the hour, or running scheduled
/// maintenance every day at a particular time.
/// </summary>
public void ScheduleAtFixedRate(TimerTask task, int delay, int period)
{
if (delay < 0 || period <= 0)
{
throw new ArgumentOutOfRangeException();
}
DoScheduleImpl(task, TimeSpan.FromMilliseconds(delay), TimeSpan.FromMilliseconds(period), true);
}
/// <summary>
/// Schedules the specified TimerTask for execution after the specified delay.
/// </summary>
public void Schedule(TimerTask task, int delay)
{
if (delay < 0)
{
throw new ArgumentOutOfRangeException();
}
DoScheduleImpl(task, TimeSpan.FromMilliseconds(delay), TimeSpan.FromMilliseconds(-1), false);
}
/// <summary>
/// Executes the given task periodically using a fixed-delay execution style
/// which prevents tasks from bunching should there be some delay such as
/// garbage collection or machine sleep.
///
/// This repeating unit of work can later be cancelled using the WaitCallback
/// that was originally used to initiate the processing.
/// </summary>
public void ExecutePeriodically(WaitCallback task, object arg, TimeSpan period)
{
lock (this.syncRoot)
{
CheckStarted();
TimerTask timerTask = timer.Schedule(task, arg, period, period);
timerTasks.Add(task, timerTask);
}
}
internal int GetTask(TimerTask task)
{
for (int i = 0; i < timers.Length; i++)
{
if (timers[i] == task)
{
return(i);
}
}
return(-1);
}
public void Insert(TimerTask task)
{
if (timers.Length == size)
{
TimerTask[] appendedTimers = new TimerTask[size * 2];
timers.CopyTo(appendedTimers, 0);
timers = appendedTimers;
}
timers[size++] = task;
UpHeap();
}
/// <summary>
/// Schedules the specified TimerTask for repeated fixed-rate execution, beginning
/// at the specified time. Subsequent executions take place at approximately regular
/// intervals, separated by the specified period.
///
/// In fixed-rate execution, each execution is scheduled relative to the scheduled execution
/// time of the initial execution. If an execution is delayed for any reason (such as garbage
/// collection or other background activity), two or more executions will occur in rapid
/// succession to "catch up."
///
/// Fixed-rate execution is appropriate for recurring activities that are sensitive to
/// absolute time, such as ringing a chime every hour on the hour, or running scheduled
/// maintenance every day at a particular time.
/// </summary>
public void ScheduleAtFixedRate(TimerTask task, DateTime when, TimeSpan period)
{
if (period.CompareTo(TimeSpan.Zero) <= 0)
{
throw new ArgumentOutOfRangeException();
}
TimeSpan delay = when - DateTime.Now;
DoScheduleImpl(task, delay, period, true);
}
/// <summary>
/// Schedules the specified TimerTask for repeated fixed-rate execution, beginning
/// at the specified time. Subsequent executions take place at approximately regular
/// intervals, separated by the specified period.
///
/// In fixed-rate execution, each execution is scheduled relative to the scheduled execution
/// time of the initial execution. If an execution is delayed for any reason (such as garbage
/// collection or other background activity), two or more executions will occur in rapid
/// succession to "catch up."
///
/// Fixed-rate execution is appropriate for recurring activities that are sensitive to
/// absolute time, such as ringing a chime every hour on the hour, or running scheduled
/// maintenance every day at a particular time.
/// </summary>
public void ScheduleAtFixedRate(TimerTask task, DateTime when, int period)
{
if (period <= 0)
{
throw new ArgumentOutOfRangeException();
}
TimeSpan delay = when - DateTime.Now;
DoScheduleImpl(task, delay, TimeSpan.FromMilliseconds(period), true);
}
private void UpHeap()
{
int current = size - 1;
int parent = (current - 1) / 2;
while (timers[current].when < timers[parent].when)
{
// swap the two
TimerTask tmp = timers[current];
timers[current] = timers[parent];
timers[parent] = tmp;
// update pos and current
current = parent;
parent = (current - 1) / 2;
}
}
public void Cancel(object task)
{
lock (this.syncRoot)
{
if (timerTasks.ContainsKey(task))
{
TimerTask ticket = timerTasks[task];
if (ticket != null)
{
ticket.Cancel();
timer.Purge(); // remove cancelled TimerTasks
}
timerTasks.Remove(task);
}
}
}
private void DoScheduleImpl(TimerTask task, TimeSpan delay, TimeSpan period, bool fixedRate)
{
if (task == null)
{
throw new ArgumentNullException("TimerTask cannot be null");
}
lock (this.impl.SyncRoot)
{
if (impl.Cancelled)
{
throw new InvalidOperationException();
}
DateTime when = DateTime.Now + delay;
lock (task.syncRoot)
{
if (task.IsScheduled)
{
throw new InvalidOperationException();
}
if (task.cancelled)
{
throw new InvalidOperationException("Task is already cancelled");
}
task.when = when;
task.period = period;
task.fixedRate = fixedRate;
}
// insert the newTask into queue
impl.InsertTask(task);
}
}
/// <summary>
/// Schedules the specified TimerTask for execution at the specified time. If the
/// time is in the past.
/// </summary>
public void Schedule(TimerTask task, DateTime when)
{
TimeSpan delay = when - DateTime.Now;
DoScheduleImpl(task, delay, TimeSpan.FromMilliseconds(-1), false);
}
public void InsertTask(TimerTask newTask)
{
// callers are synchronized
tasks.Insert(newTask);
Monitor.Pulse(this.syncRoot);
}
