public ThreadPoolTimer(TimerElapsedHandler handler, TimeSpan period, TimerDestroyedHandler destroyed)
{
_handler = handler;
_destroyed = destroyed;
newTimer = new DispatcherTimer();
// timer interval specified as 1 second
newTimer.Interval = TimeSpan.FromSeconds(1);
// Sub-routine OnTimerTick will be called at every 1 second
newTimer.Tick += delegate(object sender, EventArgs args) { _handler(this); };
// starting the timer
newTimer.Start();
}
internal ThreadPoolTimer(TimerElapsedHandler handler, TimeSpan?period = null, TimeSpan?delay = null, TimerDestroyedHandler destroyed = null)
{
_timer = new Timer(_ =>
{
if (!_cts.IsCancellationRequested)
{
handler.Invoke(this);
}
});
_destroyed = destroyed;
_timer.Change(
period: period ?? global::System.Threading.Timeout.InfiniteTimeSpan,
dueTime: delay ?? global::System.Threading.Timeout.InfiniteTimeSpan
);
}
public static ThreadPoolTimer CreateTimer(TimerElapsedHandler handler, TimeSpan delay, TimerDestroyedHandler destroyed) => new ThreadPoolTimer(handler, delay: delay, destroyed: destroyed);
public static ThreadPoolTimer CreatePeriodicTimer(TimerElapsedHandler handler, TimeSpan period, TimerDestroyedHandler destroyed) => new ThreadPoolTimer(handler, period: period, destroyed: destroyed);
public TimerHandler(TimerElapsedHandler handler, TimeSpan period, TimerDestroyedHandler destroyed)
{
_periodicTimer = ThreadPoolTimer.CreatePeriodicTimer(handler, period, destroyed);
}
public static ThreadPoolTimer CreatePeriodicTimer(TimerElapsedHandler handler, TimeSpan period, TimerDestroyedHandler destroyed)
{
return new ThreadPoolTimer(handler,period,destroyed);
}
private ThreadPoolTimer(TimerElapsedHandler handler, TimerDestroyedHandler destroyed, TimeSpan delay, bool isPeriodic)
{
Delay = delay;
if (isPeriodic)
Period = delay;
this.isPeriodic = isPeriodic;
this.handler = handler;
this.destroyed = destroyed;
this.realTimer = new Timer(t =>
{
var ltimer = (ThreadPoolTimer)t;
lock (ltimer)
{
if (ltimer.isCanceled)
return;
ltimer.isRunning = true;
}
Task.Factory.StartNew(o =>
{
ThreadPoolTimer taskedTimer = (ThreadPoolTimer)o;
try
{
taskedTimer.handler(taskedTimer);
}
finally
{
lock (ltimer)
{
taskedTimer.isRunning = false;
if (!taskedTimer.isPeriodic || taskedTimer.isCanceled)
ltimer.Cancel();
}
}
}, ltimer);
}, this, (int)delay.TotalMilliseconds, (isPeriodic) ? (int)delay.TotalMilliseconds : Timeout.Infinite);
}
/// <summary>
/// Creates a single-use timer and specifies a method to call after the timer is complete.
/// The timer is complete when the timer has expired and the final call to handler has finished.
/// </summary>
/// <param name="handler">The method to call when the timer expires.</param>
/// <param name="delay">The number of milliseconds until the timer expires.</param>
/// <param name="destroyed">The method to call after the timer is complete.</param>
/// <returns>An instance of a single-use timer.</returns>
public static ThreadPoolTimer CreateTimer(TimerElapsedHandler handler, TimeSpan delay, TimerDestroyedHandler destroyed)
{
if (handler == null)
throw new ArgumentException("handler");
return new ThreadPoolTimer(handler, destroyed, delay, isPeriodic: false);
}
