private static ScheduledFunction <T> Add <T>(
bool isFunction,
[NotNull] ScheduledFunction <T> .SchedulableDueCancellableFunctionAsync function,
[NotNull] ISchedule schedule,
int maximumHistory = -1,
Duration maximumDuration = default(Duration))
{
if (function == null)
{
throw new ArgumentNullException("function");
}
if (schedule == null)
{
throw new ArgumentNullException("schedule");
}
ScheduledFunction <T> sf = new ScheduledFunction <T>(
isFunction,
function,
schedule,
maximumHistory < 1 ? _defaultMaximumHistory : maximumHistory,
maximumDuration <= Duration.Zero ? _defaultMaximumDuration : maximumDuration);
// Update actions dictionary
_actions.AddOrUpdate(sf.ID, sf, (i, a) => sf);
// Calculate next due
sf.RecalculateNextDue(Instant.MinValue);
return(sf);
}
/// <summary>
/// Enables the specified scheduled function.
/// </summary>
/// <param name="scheduledFunction">The scheduled function.</param>
public static void Enable(ScheduledFunction scheduledFunction)
{
if (_timers.TryUpdate(scheduledFunction, new Timer(Tick, scheduledFunction, Timeout.Infinite, Timeout.Infinite), null))
{
SetTimer(scheduledFunction);
}
}
/// <summary>
/// Removes the specified scheduled function (if currently in the scheduler).
/// </summary>
/// <param name="scheduledFunction">The scheduled function.</param>
/// <returns>The scheduled function passed in.</returns>
public static ScheduledFunction Remove(ScheduledFunction scheduledFunction)
{
Timer timer;
if (_timers.TryRemove(scheduledFunction, out timer) && (timer != null))
{
timer.Dispose();
}
return(scheduledFunction);
}
/// <summary>
/// Enables the specified scheduled function.
/// </summary>
/// <param name="scheduledFunction">The scheduled function.</param>
public static void Disable(ScheduledFunction scheduledFunction)
{
Timer timer;
if ((_timers.TryGetValue(scheduledFunction, out timer)) && (timer != null))
{
if (_timers.TryUpdate(scheduledFunction, null, timer))
{
timer.Dispose();
}
}
}
/// <summary>
/// Removes the specified scheduled function.
/// </summary>
/// <param name="scheduledFunction">The scheduled action.</param>
/// <returns><see langword="true" /> if removed, <see langword="false" /> otherwise.</returns>
public static bool Remove <T>([NotNull] ScheduledFunction <T> scheduledFunction)
{
if (scheduledFunction == null)
{
throw new ArgumentNullException("scheduledFunction");
}
ScheduledAction a;
bool result = _actions.TryRemove(scheduledFunction.ID, out a);
Debug.Assert(!result || (a != null && a.ID == scheduledFunction.ID));
return(result);
}
/// <summary>
/// Ticks every second.
/// </summary>
/// <param name="state">The state.</param>
private static void Tick(object state)
{
ScheduledFunction scheduledFunction = state as ScheduledFunction;
if (scheduledFunction == null)
{
return;
}
// Check we're still due.
if (scheduledFunction.NextExecutionDue <= DateTime.Now)
{
scheduledFunction.ExecuteNow();
}
SetTimer(scheduledFunction);
}
public static ScheduledFunction <T> Add <T>(
[NotNull] ScheduledFunction <T> .SchedulableDueCancellableFunctionAsync function,
[NotNull] ISchedule schedule,
int maximumHistory = -1,
Duration maximumDuration = default(Duration))
{
if (function == null)
{
throw new ArgumentNullException("function");
}
if (schedule == null)
{
throw new ArgumentNullException("schedule");
}
return(Add(true, function, schedule, maximumHistory, maximumDuration));
}
public static ScheduledFunction <T> Add <T>(
[NotNull] ScheduledFunction <T> .SchedulableDueFunction function,
[NotNull] ISchedule schedule,
int maximumHistory = -1,
Duration maximumDuration = default(Duration))
{
if (function == null)
{
throw new ArgumentNullException("function");
}
if (schedule == null)
{
throw new ArgumentNullException("schedule");
}
return(Add(true, (d, t) => Task.FromResult(function(d)), schedule, maximumHistory, maximumDuration));
}
public static ScheduledFunction <T> Add <T>(
[NotNull] ScheduledFunction <T> .SchedulableCancellableFunctionAsync function,
[NotNull] string scheduleName,
int maximumHistory = -1,
Duration maximumDuration = default(Duration))
{
if (function == null)
{
throw new ArgumentNullException("function");
}
if (scheduleName == null)
{
throw new ArgumentNullException("scheduleName");
}
return(Add(true, (d, t) => function(t), GetSchedule(scheduleName), maximumHistory, maximumDuration));
}
/// <summary>
/// Sets the timer for a scheduled function.
/// </summary>
/// <param name="scheduledFunction">The scheduled function.</param>
private static void SetTimer(ScheduledFunction scheduledFunction)
{
Timer timer;
if ((!_timers.TryGetValue(scheduledFunction, out timer)) || (timer == null))
{
return;
}
DateTime nextDue = scheduledFunction.NextExecutionDue;
if (nextDue == DateTime.MaxValue)
{
// If we're never due again, remove the scheduled function.
if (_timers.TryRemove(scheduledFunction, out timer) && (timer != null))
{
timer.Dispose();
}
return;
}
TimeSpan dueIn = nextDue - DateTime.Now;
timer.Change(dueIn > TimeSpan.Zero ? dueIn : TimeSpan.FromTicks(1), TimeSpan.FromMilliseconds(-1));
}
/// <summary>
/// Adds the specified schedule.
/// </summary>
/// <typeparam name="TResult">The type of the result.</typeparam>
/// <param name="schedule">The schedule.</param>
/// <param name="function">The function.</param>
/// <param name="startAfter">The date time to start after.</param>
/// <param name="maximumHistory">The maximum history.</param>
/// <param name="enabled">if set to <c>true</c> then the scheduled function is enabled.</param>
/// <param name="executeImmediately">if set to <c>true</c> executes the function immediately.</param>
/// <returns>The scheduled function.</returns>
public static ScheduledFunction <TResult> Add <TResult>(Schedule schedule,
Func <ScheduledFunction <TResult>, TResult> function,
DateTime?startAfter = null, int maximumHistory = ScheduledFunction.DefaultMaximumHistory,
bool enabled = true, bool executeImmediately = false)
{
ScheduledFunction <TResult> scheduledFunction = new ScheduledFunction <TResult>(
schedule, function, startAfter ?? DateTime.Now, maximumHistory);
// If we need to execute, do so now.
if (executeImmediately)
{
scheduledFunction.ExecuteNow();
}
// Don't add a scheduled function that is never due
DateTime nextDue = scheduledFunction.NextExecutionDue;
// Check if we're ever due
if (nextDue == DateTime.MaxValue)
{
return(scheduledFunction);
}
Timer timer = enabled
? new Timer(Tick, scheduledFunction, Timeout.Infinite, Timeout.Infinite)
: null;
_timers.AddOrUpdate(scheduledFunction, timer, (sf, t) => timer);
if (enabled)
{
SetTimer(scheduledFunction);
}
return(scheduledFunction);
}
