定时循环任务执行

定时循环任务执行

using System.Timers;

/// <summary>
/// 如果要实现更复杂的功能参见以下
/// Cron在线表达式生成器(https://cron.ciding.cc/)
/// </summary>
public class ScheduledTaskExecutor
{
    private List<TaskInfo> tasks = new List<TaskInfo>();
    private int currentIndex = -1; // 初始为 -1 表示还未开始执行第一个任务
    System.Timers.Timer timer = new System.Timers.Timer();
    private bool isRunning = false;

    public ScheduledTaskExecutor()
    {
    }

    private void OnTimedEvent(object? source, ElapsedEventArgs e)
    {
        var dTime = e.SignalTime;// DateTime.Now;
        if (isRunning)
        {
            tasks.ForEach(task =>
            {
                task.RunTaskAsync(dTime);
            });
        }
    }

    internal void AddTask(Action<TaskInfo> action, TimeSpan timeSpan, string? descript = null)
    {
        lock (tasks)
        {
            tasks.Add(new TaskInfo(action, timeSpan, ""));
        }
    }
    internal void AddTask(TaskInfo taskInfo)
    {
        lock (tasks)
        {
            tasks.Add(taskInfo);
        }
    }

    public void Start()
    {
        timer = new System.Timers.Timer();
        timer.AutoReset = true;
        timer.Elapsed += OnTimedEvent;
        isRunning = true;
        timer.Start();
        //Task.Run(new Action(() =>
        //{

        //    do
        //    {
        //        //Console.WriteLine(DateTime.Now);
        //        var dt = DateTime.Now;// e.SignalTime;
        //        try
        //        {
        //            //Console.WriteLine($"{dt:hh:mm:ss.ffff}");
        //            tasks.ForEach(task =>
        //            {
        //                task.RunTaskAsync(dt);
        //            });
        //        }
        //        catch (Exception ex)
        //        {

        //        }
        //        Thread.Sleep(100);
        //    } while (true);
        //})); 
    }

    public void Stop()
    {
        if (isRunning)
        {
            isRunning = false;
            timer.Stop();
        }
    }

    public void ClearTasks()
    {
        lock (tasks)
        {
            tasks.Clear();
        }
    }


}
/// <summary>
/// 任务信息
/// </summary>
public class TaskInfo
{

    /// <summary>
    /// 执行动作
    /// </summary>
    //public Action WorkTaskAction { get; }
    public Action<TaskInfo> WorkTaskAction1 { get; private set; }

    /// <summary>
    /// 时间间隔
    /// </summary>
    public TimeSpan TimeSpan { get; }
    /// <summary>
    /// 下一次执行时间
    /// </summary>
    public DateTime NextRunTime { get; private set; }
    public string Descript { get; }

    /// <summary>
    /// 是否异步执行
    /// </summary>
    public bool IsAsync { get; set; } = false;
    /// <summary>
    /// 终止时间
    /// </summary>
    public DateTime EndDate { get; set; }
    /// <summary>
    ///  执行次数
    /// </summary>
    public int RunCount { get; private set; } = 0;


    public TaskInfo(Action<TaskInfo> action, TimeSpan timeSpan, string? descript = null)
    {
        WorkTaskAction1 = action;
        this.TimeSpan = timeSpan;
        NextRunTime = (DateTime.Now + timeSpan);
        Descript = descript ?? WorkTaskAction1.Method.Name;
    }

    public TaskInfo(TimeSpan timeSpan)
    {
        this.TimeSpan = timeSpan;
    }

    /// <summary>
    ///  
    /// </summary>
    /// <param name="nowDTime">当前时间</param>
    internal void RunTaskAsync(DateTime nowDTime)
    {
        if (NextRunTime < nowDTime)
        {
            RunCount++;
            NextRunTime = nowDTime + TimeSpan;// dt.AddMilliseconds(Interval.TotalMilliseconds);// (DateTime.Now + Interval);

            //如果时效要求高，使用此线程池
            //ThreadPool.QueueUserWorkItem(a =>
            //{
            //    WorkTaskAction1?.Invoke(this);
            //});
            //ThreadPool.QueueUserWorkItem(a =>
            //{
            //    WorkTaskAction?.Invoke();
            //}); 
            Task.Run(() =>
            {
                WorkTaskAction1?.Invoke(this);
            }).ContinueWith(t =>
            {
                if (t.IsFaulted) // 检查任务是否因为未处理的异常而错误
                {
                    // 打印异常信息或执行其他错误处理
                    foreach (var innerException in t.Exception.Flatten().InnerExceptions)
                    {
                        Console.WriteLine($"[{Descript}]Exception: " + innerException.Message);
                    }
                }
                else
                {
                    Console.WriteLine($"[[{Descript}]任务完成事件触发!");
                }
            }, TaskContinuationOptions.ExecuteSynchronously); //.RunSynchronously()//.Wait(); 

        }

    }
    /// <summary>
    /// 开始时间，如果要从中午12点开始执行[yyyy.MM.dd 12:00:00]
    /// </summary>
    /// <param name="v">yyyy.MM.dd HH:mm:ss</param>
    /// <returns></returns>
    internal TaskInfo StartDate(string v)
    {
        NextRunTime = DateTime.Parse(DateTime.Now.ToString(v));// DateTime.ParseExact(DateTime.Now.ToString(v), "yyyy.MM.dd HH:mm:ss");
        if (NextRunTime < DateTime.Now)
        {
            NextRunTime = DateTime.Parse(DateTime.Now.AddDays(1).ToString(v));
        }
        return this;
    }
}

// 示例代码
class Program
{
    static void Main(string[] args)
    {
        var executor = new ScheduledTaskExecutor();

        executor.AddTask((info) => Console.WriteLine($"Task 1 executed at 10s,{DateTime.Now:HH:mm:sss.fff},{info.RunCount}"), TimeSpan.FromSeconds(10));
        
        executor.AddTask((info) =>
        {
            Console.WriteLine($"Task 2 executed at 1.0s ,{DateTime.Now:HH:mm:sss.fff},{info.RunCount}");
            var ttemp = new Random().Next(0, 10);
            if (ttemp > 5)
            {
                throw new Exception($"{ttemp},throw new Exception sdfsdf");
            }
        }, TimeSpan.FromSeconds(1.0));
        executor.AddTask(TestFunction, TimeSpan.FromSeconds(0.5));
        var taskInfo = new TaskInfo(TestFunction, TimeSpan.FromSeconds(0.5),"初始开始时间执行").StartDate("yyyy.MM.dd HH:32:00"); 
        executor.AddTask(taskInfo);
        executor.Start();

        Console.WriteLine("Press any key to stop...");

        Console.ReadKey();

        executor.Stop();
    }

    private static void TestFunction(TaskInfo info)
    {
        Console.WriteLine($"{info.Descript} executed at {info.TimeSpan} ,{DateTime.Now:HH:mm:sss.fff} {info.RunCount}");
        var ttemp = new Random().Next(0, 10);
        if (ttemp > 5)
        {
            throw new Exception($"{ttemp},XXXException,执行次数 {info.RunCount}");
        }
    }
}