public virtual SchedulingItem TryGet(string jobId)
{
lock (SyncRoot)
{
var context = SchedulingItems.FirstOrDefault(jc => jc.ManagedJob.Id == jobId);
return(context == null ? null : context.ManagedJob);
}
}
public virtual void CancelAll()
{
lock (SyncRoot)
{
if (IsDisposed)
{
return;
}
Timer.Change(Timeout.Infinite, Timeout.Infinite);
NextExecution = null;
SchedulingItems.Clear();
}
}
protected virtual void RunPendingJobs()
{
var now = SchedulingTimeHelpers.Now();
var dueJobs = new List <SchedulingItemContext>();
SchedulingItemContext currentJob = null;
for (int i = 0; i < SchedulingItems.Count; i++)
{
var job = SchedulingItems[i];
if (job.NextExecution.Value > now)
{
break;
}
dueJobs.Add(job);
}
try
{
for (var i = dueJobs.Count - 1; i >= 0; i--)
{
currentJob = dueJobs[i];
currentJob.ExecuteAsync(this);
if (currentJob.NextExecution.HasValue)
{
IsSorted = false;
}
else
{
SchedulingItems.RemoveAt(i);
}
}
}
catch (Exception e)
{
if (!SubmitJobException(currentJob.ManagedJob, e))
{
throw;
}
}
}
public virtual bool Cancel(string id)
{
lock (SyncRoot)
{
for (int i = 0; i < SchedulingItems.Count; i++)
{
var job = SchedulingItems[i];
if (job.ManagedJob.Id == id)
{
SchedulingItems.RemoveAt(i);
job.ManagedJob.Cancel();
if (i == 0)
{
Reschedule();
}
return(true);
}
}
}
return(false);
}
public virtual void Submit(SchedulingItem schedulingItem, Action <SchedulingItem> callback)
{
if (schedulingItem == null)
{
throw new ArgumentNullException("schedulingItem");
}
if (callback == null)
{
throw new ArgumentNullException("callback");
}
var interval = schedulingItem.Interval;
if (interval.HasValue && interval.Value.TotalMilliseconds < MinJobInterval)
{
string msg = "Interval of {0} ms is too small - a minimum interval of {1} ms is accepted.";
msg = String.Format(msg, interval.Value.TotalMilliseconds, MinJobInterval);
throw new InvalidOperationException(msg);
}
var context = new SchedulingItemContext(schedulingItem, callback);
lock (SyncRoot)
{
if (NextExecution == null || context.NextExecution <= NextExecution.Value)
{
SchedulingItems.Insert(0, context);
if (NextExecution == null || NextExecution.Value.Subtract(SchedulingTimeHelpers.Now()).TotalMilliseconds > MinJobInterval)
{
Reschedule();
}
}
else
{
SchedulingItems.Add(context);
IsSorted = false;
}
}
}
protected virtual void VerifySystemTime()
{
if (LastTimerInterval == Timeout.Infinite)
{
return;
}
var now = SchedulingTimeHelpers.Now();
var pauseDuration = now.Subtract(LastTimerRun);
var timeDivergence = pauseDuration.TotalMilliseconds - LastTimerInterval;
if (timeDivergence > 1000 || timeDivergence < 1000)
{
bool changeExpirationTime = ReschedulingType ==
ReschedulingType.RescheduleNextExecutionAndExpirationTime;
SchedulingItems.ForEach(jc =>
{
jc.NextExecution = jc.NextExecution.Value.AddMilliseconds(timeDivergence);
if (changeExpirationTime && jc.ManagedJob.ExpirationTime.HasValue)
{
jc.ManagedJob.ExpirationTime = jc.ManagedJob.ExpirationTime.Value.AddMilliseconds(timeDivergence);
}
});
}
}
protected void Sort()
{
SchedulingItems.Sort((first, second) => first.NextExecution.Value.CompareTo(second.NextExecution.Value));
IsSorted = true;
}
