Scheduler for multiple instances in C#

Hello folks, today I will explain regarding Scheduler which would work for multiple instances. Scheduler will be used to do schedule tasks in our project. Like someone wants to send email to all customers at specific time and date, one could use this kind of scheduler.

In this example we will use Task, to use this we would require System.Threading.Tasks namespace. In my future post I will explain regarding Task in detail.

Let have look into scheduler class code:

using System;
using System.Threading;
using System.Threading.Tasks;

namespace SchedulerConsole
{
    class Schedulers : IDisposable
    {
        public CancellationTokenSource m_ctSource;
        public bool runScheduler = true;
        public int period;
        string interval;
        public enum Scheduled { EveryDay, EveryWeek, EveryMonth, EveryYear, EveryMinutes, EverySeconds }
        public void StartBackProcess(string strThread, Scheduled sc)
        {
            if (m_ctSource != null)
                m_ctSource.Cancel();

            runScheduler = true;
            interval = sc.ToString();//"EverySeconds";
            DateTime date = DateTime.Now;
            period = 1;
            var nextDateValue = getNextDate(date, getScheduler(interval));
            runCodeAt(nextDateValue, getScheduler(interval), interval, date, strThread);
        }
        private DateTime getNextDate(DateTime date, Scheduled scheduler)
        {
            switch (scheduler)
            {
                case Scheduled.EveryMinutes:
                    return date.AddMinutes(period);
                case Scheduled.EveryDay:
                    return date.AddDays(period);
                case Scheduled.EveryWeek:
                    return date.AddDays(period);
                case Scheduled.EveryMonth:
                    return date.AddDays(period);
                case Scheduled.EveryYear:
                    return date.AddYears(period);
                case Scheduled.EverySeconds:
                    return date.AddSeconds(period);
                default:
                    throw new Exception("Invalid scheduler");
            }
        }
        private void methodToCall(DateTime time, string interval, string strThread)
        {
            try
            {
                Console.WriteLine("Method called for {0} on {1}", strThread, DateTime.Now);
            }
            catch (Exception ex)
            {
            }
        }
        private Scheduled getScheduler(string interval)
        {
            if (interval.Trim() == "EveryMinutes") return Scheduled.EveryMinutes;
            else if (interval.Trim() == "EveryDay") return Scheduled.EveryDay;
            else if (interval.Trim() == "EveryWeek") return Scheduled.EveryWeek;
            else if (interval.Trim() == "EveryMonth") return Scheduled.EveryMonth;
            else if (interval.Trim() == "EverySeconds") return Scheduled.EverySeconds;
            else return Scheduled.EveryDay;
        }
        Task Delay(TimeSpan ts)
        {
            return Task.Factory.StartNew(() => { Thread.Sleep(ts); });
        }
        private void runCodeAt(DateTime NextDate, Scheduled scheduler, string interval, DateTime configuredDate, string strThread)
        {
            try
            {
                m_ctSource = new CancellationTokenSource();

                var dateNow = configuredDate;
                TimeSpan ts;
                if (NextDate > dateNow)
                    ts = NextDate - dateNow;
                else
                {
                    NextDate = getNextDate(NextDate, scheduler);
                    ts = NextDate - dateNow;
                }

                if (!runScheduler) m_ctSource.Cancel();

                methodToCall(NextDate, interval, strThread);
                Task task = Delay(ts);
                task.ContinueWith((x) => { runCodeAt(getNextDate(NextDate, scheduler), scheduler, interval, NextDate, strThread); }, m_ctSource.Token);
            }
            catch { }
        }
        public void Dispose()
        {
            m_ctSource.Dispose();
        }
    }
}

Call this call from your code as shown below:

using System;

namespace SchedulerConsole
{
    class Program 
    {
        static void Main(string[] args)
        {
            Schedulers sc= new Schedulers(); 
            sc.StartBackProcess("Method1",Schedulers.Scheduled.EverySeconds);
            Schedulers sc1 = new Schedulers();
            sc1.StartBackProcess("Method2", Schedulers.Scheduled.EverySeconds);
            Console.ReadKey();
        }
        
    }
}

Output: