Scheduler.cs

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Waher.Events;
 
namespace Waher.Runtime.Timing
{
    public delegate void ScheduledEventCallback(object State);
 
    public delegate Task ScheduledEventCallbackAsync(object State);
 
    public class Scheduler : IDisposable
    {
        private static readonly TimeSpan OnlyOnce = TimeSpan.FromMilliseconds(-1);
        private static readonly TimeSpan OneDay = TimeSpan.FromDays(1);
 
        private readonly SortedDictionary<DateTime, ScheduledEvent> events = new SortedDictionary<DateTime, ScheduledEvent>();
        private readonly Random gen = new Random();
        private Timer timer = null;
        private bool disposed = false;
 
        public Scheduler()
        {
        }
 
        public void Dispose()
        {
            if (!this.disposed)
            {
                this.disposed = true;
 
                this.timer?.Dispose();
                this.timer = null;
 
                this.events.Clear();
            }
        }
 
        public DateTime Add(DateTime When, ScheduledEventCallback Callback, object State)
        {
            lock (this.events)
            {
                while (this.events.ContainsKey(When))
                    When = When.AddTicks(this.gen.Next(1, 10));
 
                this.events[When] = new ScheduledEvent(When, Callback, State);
                this.RecalcTimerLocked();
            }
 
            return When;
        }
 
        public DateTime Add(DateTime When, ScheduledEventCallbackAsync Callback, object State)
        {
            lock (this.events)
            {
                while (this.events.ContainsKey(When))
                    When = When.AddTicks(this.gen.Next(1, 10));
 
                this.events[When] = new ScheduledEvent(When, Callback, State);
                this.RecalcTimerLocked();
            }
 
            return When;
        }
 
        private void RecalcTimerLocked()
        {
            this.timer?.Dispose();
            this.timer = null;
 
            LinkedList<DateTime> ToRemove = null;
            DateTime Now = DateTime.Now;
            TimeSpan TimeLeft;
 
            foreach (KeyValuePair<DateTime, ScheduledEvent> Event in this.events)
            {
                TimeLeft = Event.Key - Now;
                if (TimeLeft <= TimeSpan.Zero)
                {
                    if (ToRemove is null)
                        ToRemove = new LinkedList<DateTime>();
 
                    ToRemove.AddLast(Event.Key);
 
                    Task.Run(Event.Value.Execute);
                }
                else
                {
                    if (TimeLeft < OneDay)
                        this.timer = new Timer(this.TimerElapsed, null, TimeLeft, OnlyOnce);
                    else
                        this.timer = new Timer(this.TimerElapsed, null, OneDay, OnlyOnce);
 
                    break;
                }
            }
 
            if (!(ToRemove is null))
            {
                foreach (DateTime TP in ToRemove)
                    this.events.Remove(TP);
            }
        }
 
        private void TimerElapsed(object P)
        {
            try
            {
                lock (this.events)
                {
                    this.RecalcTimerLocked();
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public void Clear()
        {
            try
            {
                lock (this.events)
                {
                    this.events.Clear();
                    this.RecalcTimerLocked();
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public bool Remove(DateTime When)
        {
            lock (this.events)
            {
                if (this.events.Remove(When))
                {
                    this.RecalcTimerLocked();
                    return true;
                }
            }
 
            return false;
        }
 
    }
}