.NET 纯原生实现 Cron 定时任务执行，未依赖第三方组件

本文主要是介绍.NET 纯原生实现 Cron 定时任务执行，未依赖第三方组件，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

常用的定时任务组件有 Quartz.Net 和 Hangfire 两种，这两种是使用人数比较多的定时任务组件，个人以前也是使用的 Hangfire ，慢慢的发现自己想要的其实只是一个能够根据 Cron 表达式来定时执行函数的功能，Quartz.Net 和 Hangfire 虽然都能实现这个目的，但是他们都只用来实现 Cron表达式解析定时执行函数就显得太笨重了，所以想着以 解析 Cron表达式定期执行函数为目的，编写了下面的一套逻辑。

首先为了解析 Cron表达式，我们需要一个CronHelper ,代码如下

using System.Globalization;
using System.Text;
using System.Text.RegularExpressions;

namespace Common
{
    public class CronHelper
    {
        /// <summary>
        /// 获取当前时间之后下一次触发时间
        /// </summary>
        /// <param name="cronExpression"></param>
        /// <returns></returns>
        public static DateTimeOffset GetNextOccurrence(string cronExpression)
        {
            return GetNextOccurrence(cronExpression, DateTimeOffset.UtcNow);
        }

        /// <summary>
        /// 获取给定时间之后下一次触发时间
        /// </summary>
        /// <param name="cronExpression"></param>
        /// <param name="afterTimeUtc"></param>
        /// <returns></returns>
        public static DateTimeOffset GetNextOccurrence(string cronExpression, DateTimeOffset afterTimeUtc)
        {
            return new CronExpression(cronExpression).GetTimeAfter(afterTimeUtc)!.Value;
        }

        /// <summary>
        /// 获取当前时间之后N次触发时间
        /// </summary>
        /// <param name="cronExpression"></param>
        /// <param name="count"></param>
        /// <returns></returns>
        public static List<DateTimeOffset> GetNextOccurrences(string cronExpression, int count)
        {
            return GetNextOccurrences(cronExpression, DateTimeOffset.UtcNow, count);
        }

        /// <summary>
        /// 获取给定时间之后N次触发时间
        /// </summary>
        /// <param name="cronExpression"></param>
        /// <param name="afterTimeUtc"></param>
        /// <returns></returns>
        public static List<DateTimeOffset> GetNextOccurrences(string cronExpression, DateTimeOffset afterTimeUtc, int count)
        {
            CronExpression cron = new(cronExpression);

            List<DateTimeOffset> dateTimeOffsets = new();

            for (int i = 0; i < count; i++)
            {
                afterTimeUtc = cron.GetTimeAfter(afterTimeUtc)!.Value;

                dateTimeOffsets.Add(afterTimeUtc);
            }
            return dateTimeOffsets;
        }

        private class CronExpression
        {
            private const int Second = 0;

            private const int Minute = 1;

            private const int Hour = 2;

            private const int DayOfMonth = 3;

            private const int Month = 4;

            private const int DayOfWeek = 5;

            private const int Year = 6;

            private const int AllSpecInt = 99;

            private const int NoSpecInt = 98;

            private const int AllSpec = AllSpecInt;

            private const int NoSpec = NoSpecInt;

            private SortedSet<int> seconds = null!;

            private SortedSet<int> minutes = null!;

            private SortedSet<int> hours = null!;

            private SortedSet<int> daysOfMonth = null!;

            private SortedSet<int> months = null!;

            private SortedSet<int> daysOfWeek = null!;

            private SortedSet<int> years = null!;

            private bool lastdayOfWeek;

            private int everyNthWeek;

            private int nthdayOfWeek;

            private bool lastdayOfMonth;

            private bool nearestWeekday;

            private int lastdayOffset;

            private static readonly Dictionary<string, int> monthMap = new Dictionary<string, int>(20);

            private static readonly Dictionary<string, int> dayMap = new Dictionary<string, int>(60);

            private static readonly int MaxYear = DateTime.Now.Year + 100;

            private static readonly char[] splitSeparators = { ' ', '\t', '\r', '\n' };

            private static readonly char[] commaSeparator = { ',' };

            private static readonly Regex regex = new Regex("^L-[0-9]*[W]?", RegexOptions.Compiled);

            private static readonly TimeZoneInfo timeZoneInfo = TimeZoneInfo.Local;

            public CronExpression(string cronExpression)
            {
                if (monthMap.Count == 0)
                {
                    monthMap.Add("JAN", 0);
                    monthMap.Add("FEB", 1);
                    monthMap.Add("MAR", 2);
                    monthMap.Add("APR", 3);
                    monthMap.Add("MAY", 4);
                    monthMap.Add("JUN", 5);
                    monthMap.Add("JUL", 6);
                    monthMap.Add("AUG", 7);
                    monthMap.Add("SEP", 8);
                    monthMap.Add("OCT", 9);
                    monthMap.Add("NOV", 10);
                    monthMap.Add("DEC", 11);

                    dayMap.Add("SUN", 1);
                    dayMap.Add("MON", 2);
                    dayMap.Add("TUE", 3);
                    dayMap.Add("WED", 4);
                    dayMap.Add("THU", 5);
                    dayMap.Add("FRI", 6);
                    dayMap.Add("SAT", 7);
                }

                if (cronExpression == null)
                {
                    throw new ArgumentException("cronExpression 不能为空");
                }

                CronExpressionString = CultureInfo.InvariantCulture.TextInfo.ToUpper(cronExpression);
                BuildExpression(CronExpressionString);
            }

            /// <summary>
            /// 构建表达式
            /// </summary>
            /// <param name="expression"></param>
            /// <exception cref="FormatException"></exception>
            private void BuildExpression(string expression)
            {
                try
                {
                    seconds ??= new SortedSet<int>();
                    minutes ??= new SortedSet<int>();
                    hours ??= new SortedSet<int>();
                    daysOfMonth ??= new SortedSet<int>();
                    months ??= new SortedSet<int>();
                    daysOfWeek ??= new SortedSet<int>();
                    years ??= new SortedSet<int>();

                    int exprOn = Second;

                    string[] exprsTok = expression.Split(splitSeparators, StringSplitOptions.RemoveEmptyEntries);
                    foreach (string exprTok in exprsTok)
                    {
                        string expr = exprTok.Trim();

                        if (expr.Length == 0)
                        {
                            continue;
                        }
                        if (exprOn > Year)
                        {
                            break;
                        }

                        if (exprOn == DayOfMonth && expr.IndexOf('L') != -1 && expr.Length > 1 && expr.IndexOf(",", StringComparison.Ordinal) >= 0)
                        {
                            throw new FormatException("不支持在月份的其他日期指定“L”和“LW”");
                        }
                        if (exprOn == DayOfWeek && expr.IndexOf('L') != -1 && expr.Length > 1 && expr.IndexOf(",", StringComparison.Ordinal) >= 0)
                        {
                            throw new FormatException("不支持在一周的其他日期指定“L”");
                        }
                        if (exprOn == DayOfWeek && expr.IndexOf('#') != -1 && expr.IndexOf('#', expr.IndexOf('#') + 1) != -1)
                        {
                            throw new FormatException("不支持指定多个“第N”天。");
                        }

                        string[] vTok = expr.Split(commaSeparator);
                        foreach (string v in vTok)
                        {
                            StoreExpressionVals(0, v, exprOn);
                        }

                        exprOn++;
                    }

                    if (exprOn <= DayOfWeek)
                    {
                        throw new FormatException("表达式意料之外的结束。");
                    }

                    if (exprOn <= Year)
                    {
                        StoreExpressionVals(0, "*", Year);
                    }

                    var dow = GetSet(DayOfWeek);
                    var dom = GetSet(DayOfMonth);

                    bool dayOfMSpec = !dom.Contains(NoSpec);
                    bool dayOfWSpec = !dow.Contains(NoSpec);

                    if (dayOfMSpec && !dayOfWSpec)
                    {
                        // skip
                    }
                    else if (dayOfWSpec && !dayOfMSpec)
                    {
                        // skip
                    }
                    else
                    {
                        throw new FormatException("不支持同时指定星期和日参数。");
                    }
                }
                catch (FormatException)
                {
                    throw;
                }
                catch (Exception e)
                {
                    throw new FormatException($"非法的 cron 表达式格式 ({e.Message})", e);
                }
            }

            /// <summary>
            /// Stores the expression values.
            /// </summary>
            /// <param name="pos">The position.</param>
            /// <param name="s">The string to traverse.</param>
            /// <param name="type">The type of value.</param>
            /// <returns></returns>
            private int StoreExpressionVals(int pos, string s, int type)
            {
                int incr = 0;
                int i = SkipWhiteSpace(pos, s);
                if (i >= s.Length)
                {
                    return i;
                }
                char c = s[i];
                if (c >= 'A' && c <= 'Z' && !s.Equals("L") && !s.Equals("LW") && !regex.IsMatch(s))
                {
                    string sub = s.Substring(i, 3);
                    int sval;
                    int eval = -1;
                    if (type == Month)
                    {
                        sval = GetMonthNumber(sub) + 1;
                        if (sval <= 0)
                        {
                            throw new FormatException($"无效的月份值：'{sub}'");
                        }
                        if (s.Length > i + 3)
                        {
                            c = s[i + 3];
                            if (c == '-')
                            {
                                i += 4;
                                sub = s.Substring(i, 3);
                                eval = GetMonthNumber(sub) + 1;
                                if (eval <= 0)
                                {
                                    throw new FormatException(
                                        $"无效的月份值： '{sub}'");
                                }
                            }
                        }
                    }
                    else if (type == DayOfWeek)
                    {
                        sval = GetDayOfWeekNumber(sub);
                        if (sval < 0)
                        {
                            throw new FormatException($"无效的星期几值： '{sub}'");
                        }
                        if (s.Length > i + 3)
                        {
                            c = s[i + 3];
                            if (c == '-')
                            {
                                i += 4;
                                sub = s.Substring(i, 3);
                                eval = GetDayOfWeekNumber(sub);
                                if (eval < 0)
                                {
                                    throw new FormatException(
                                        $"无效的星期几值： '{sub}'");
                                }
                            }
                            else if (c == '#')
                            {
                                try
                                {
                                    i += 4;
                                    nthdayOfWeek = Convert.ToInt32(s.Substring(i), CultureInfo.InvariantCulture);
                                    if (nthdayOfWeek is < 1 or > 5)
                                    {
                                        throw new FormatException("周的第n天小于1或大于5");
                                    }
                                }
                                catch (Exception)
                                {
                                    throw new FormatException("1 到 5 之间的数值必须跟在“#”选项后面");
                                }
                            }
                            else if (c == '/')
                            {
                                try
                                {
                                    i += 4;
                                    everyNthWeek = Convert.ToInt32(s.Substring(i), CultureInfo.InvariantCulture);
                                    if (everyNthWeek is < 1 or > 5)
                                    {
                                        throw new FormatException("每个星期<1或>5");
                                    }
                                }
                                catch (Exception)
                                {
                                    throw new FormatException("1 到 5 之间的数值必须跟在 '/' 选项后面");
                                }
                            }
                            else if (c == 'L')
                            {
                                lastdayOfWeek = true;
                                i++;
                            }
                            else
                            {
                                throw new FormatException($"此位置的非法字符：'{sub}'");
                            }
                        }
                    }
                    else
                    {
                        throw new FormatException($"此位置的非法字符：'{sub}'");
                    }
                    if (eval != -1)
                    {
                        incr = 1;
                    }
                    AddToSet(sval, eval, incr, type);
                    return i + 3;
                }

                if (c == '?')
                {
                    i++;
                    if (i + 1 < s.Length && s[i] != ' ' && s[i + 1] != '\t')
                    {
                        throw new FormatException("'?' 后的非法字符: " + s[i]);
                    }
                    if (type != DayOfWeek && type != DayOfMonth)
                    {
                        throw new FormatException(
                            "'?' 只能为月日或周日指定。");
                    }
                    if (type == DayOfWeek && !lastdayOfMonth)
                    {
                        int val = daysOfMonth.LastOrDefault();
                        if (val == NoSpecInt)
                        {
                            throw new FormatException(
                                "'?' 只能为月日或周日指定。");
                        }
                    }

                    AddToSet(NoSpecInt, -1, 0, type);
                    return i;
                }

                var startsWithAsterisk = c == '*';
                if (startsWithAsterisk || c == '/')
                {
                    if (startsWithAsterisk && i + 1 >= s.Length)
                    {
                        AddToSet(AllSpecInt, -1, incr, type);
                        return i + 1;
                    }
                    if (c == '/' && (i + 1 >= s.Length || s[i + 1] == ' ' || s[i + 1] == '\t'))
                    {
                        throw new FormatException("'/' 后面必须跟一个整数。");
                    }
                    if (startsWithAsterisk)
                    {
                        i++;
                    }
                    c = s[i];
                    if (c == '/')
                    {
                        // is an increment specified?
                        i++;
                        if (i >= s.Length)
                        {
                            throw new FormatException("字符串意外结束。");
                        }

                        incr = GetNumericValue(s, i);

                        i++;
                        if (incr > 10)
                        {
                            i++;
                        }
                        CheckIncrementRange(incr, type);
                    }
                    else
                    {
                        if (startsWithAsterisk)
                        {
                            throw new FormatException("星号后的非法字符：" + s);
                        }
                        incr = 1;
                    }

                    AddToSet(AllSpecInt, -1, incr, type);
                    return i;
                }
                if (c == 'L')
                {
                    i++;
                    if (type == DayOfMonth)
                    {
                        lastdayOfMonth = true;
                    }
                    if (type == DayOfWeek)
                    {
                        AddToSet(7, 7, 0, type);
                    }
                    if (type == DayOfMonth && s.Length > i)
                    {
                        c = s[i];
                        if (c == '-')
                        {
                            ValueSet vs = GetValue(0, s, i + 1);
                            lastdayOffset = vs.theValue;
                            if (lastdayOffset > 30)
                            {
                                throw new FormatException("与最后一天的偏移量必须 <= 30");
                            }
                            i = vs.pos;
                        }
                        if (s.Length > i)
                        {
                            c = s[i];
                            if (c == 'W')
                            {
                                nearestWeekday = true;
                                i++;
                            }
                        }
                    }
                    return i;
                }
                if (c >= '0' && c <= '9')
                {
                    int val = Convert.ToInt32(c.ToString(), CultureInfo.InvariantCulture);
                    i++;
                    if (i >= s.Length)
                    {
                        AddToSet(val, -1, -1, type);
                    }
                    else
                    {
                        c = s[i];
                        if (c >= '0' && c <= '9')
                        {
                            ValueSet vs = GetValue(val, s, i);
                            val = vs.theValue;
                            i = vs.pos;
                        }
                        i = CheckNext(i, s, val, type);
                        return i;
                    }
                }
                else
                {
                    throw new FormatException($"意外字符：{c}");
                }

                return i;
            }

            // ReSharper disable once UnusedParameter.Local
            private static void CheckIncrementRange(int incr, int type)
            {
                if (incr > 59 && (type == Second || type == Minute))
                {
                    throw new FormatException($"增量 > 60 : {incr}");
                }
                if (incr > 23 && type == Hour)
                {
                    throw new FormatException($"增量 > 24 : {incr}");
                }
                if (incr > 31 && type == DayOfMonth)
                {
                    throw new FormatException($"增量 > 31 : {incr}");
                }
                if (incr > 7 && type == DayOfWeek)
                {
                    throw new FormatException($"增量 > 7 : {incr}");
                }
                if (incr > 12 && type == Month)
                {
                    throw new FormatException($"增量 > 12 : {incr}");
                }
            }

            /// <summary>
            /// Checks the next value.
            /// </summary>
            /// <param name="pos">The position.</param>
            /// <param name="s">The string to check.</param>
            /// <param name="val">The value.</param>
            /// <param name="type">The type to search.</param>
            /// <returns></returns>
            private int CheckNext(int pos, string s, int val, int type)
            {
                int end = -1;
                int i = pos;

                if (i >= s.Length)
                {
                    AddToSet(val, end, -1, type);
                    return i;
                }

                char c = s[pos];

                if (c == 'L')
                {
                    if (type == DayOfWeek)
                    {
                        if (val < 1 || val > 7)
                        {
                            throw new FormatException("星期日值必须介于1和7之间");
                        }
                        lastdayOfWeek = true;
                    }
                    else
                    {
                        throw new FormatException($"'L' 选项在这里无效。(位置={i})");
                    }
                    var data = GetSet(type);
                    data.Add(val);
                    i++;
                    return i;
                }

                if (c == 'W')
                {
                    if (type == DayOfMonth)
                    {
                        nearestWeekday = true;
                    }
                    else
                    {
                        throw new FormatException($"'W' 选项在这里无效。 (位置={i})");
                    }
                    if (val > 31)
                    {
                        throw new FormatException("'W' 选项对于大于 31 的值（一个月中的最大天数）没有意义");
                    }

                    var data = GetSet(type);
                    data.Add(val);
                    i++;
                    return i;
                }

                if (c == '#')
                {
                    if (type != DayOfWeek)
                    {
                        throw new FormatException($"'#' 选项在这里无效。 (位置={i})");
                    }
                    i++;
                    try
                    {
                        nthdayOfWeek = Convert.ToInt32(s.Substring(i), CultureInfo.InvariantCulture);
                        if (nthdayOfWeek is < 1 or > 5)
                        {
                            throw new FormatException("周的第n天小于1或大于5");
                        }
                    }
                    catch (Exception)
                    {
                        throw new FormatException("1 到 5 之间的数值必须跟在“#”选项后面");
                    }

                    var data = GetSet(type);
                    data.Add(val);
                    i++;
                    return i;
                }

                if (c == 'C')
                {
                    if (type == DayOfWeek)
                    {

                    }
                    else if (type == DayOfMonth)
                    {

                    }
                    else
                    {
                        throw new FormatException($"'C' 选项在这里无效。(位置={i})");
                    }
                    var data = GetSet(type);
                    data.Add(val);
                    i++;
                    return i;
                }

                if (c == '-')
                {
                    i++;
                    c = s[i];
                    int v = Convert.ToInt32(c.ToString(), CultureInfo.InvariantCulture);
                    end = v;
                    i++;
                    if (i >= s.Length)
                    {
                        AddToSet(val, end, 1, type);
                        return i;
                    }
                    c = s[i];
                    if (c >= '0' && c <= '9')
                    {
                        ValueSet vs = GetValue(v, s, i);
                        int v1 = vs.theValue;
                        end = v1;
                        i = vs.pos;
                    }
                    if (i < s.Length && s[i] == '/')
                    {
                        i++;
                        c = s[i];
                        int v2 = Convert.ToInt32(c.ToString(), CultureInfo.InvariantCulture);
                        i++;
                        if (i >= s.Length)
                        {
                            AddToSet(val, end, v2, type);
                            return i;
                        }
                        c = s[i];
                        if (c >= '0' && c <= '9')
                        {
                            ValueSet vs = GetValue(v2, s, i);
                            int v3 = vs.theValue;
                            AddToSet(val, end, v3, type);
                            i = vs.pos;
                            return i;
                        }
                        AddToSet(val, end, v2, type);
                        return i;
                    }
                    AddToSet(val, end, 1, type);
                    return i;
                }

                if (c == '/')
                {
                    if (i + 1 >= s.Length || s[i + 1] == ' ' || s[i + 1] == '\t')
                    {
                        throw new FormatException("\'/\' 后面必须跟一个整数。");
                    }

                    i++;
                    c = s[i];
                    int v2 = Convert.ToInt32(c.ToString(), CultureInfo.InvariantCulture);
                    i++;
                    if (i >= s.Length)
                    {
                        CheckIncrementRange(v2, type);
                        AddToSet(val, end, v2, type);
                        return i;
                    }
                    c = s[i];
                    if (c >= '0' && c <= '9')
                    {
                        ValueSet vs = GetValue(v2, s, i);
                        int v3 = vs.theValue;
                        CheckIncrementRange(v3, type);
                        AddToSet(val, end, v3, type);
                        i = vs.pos;
                        return i;
                    }
                    throw new FormatException($"意外的字符 '{c}' 后 '/'");
                }

                AddToSet(val, end, 0, type);
                i++;
                return i;
            }

            /// <summary>
            /// Gets the cron expression string.
            /// </summary>
            /// <value>The cron expression string.</value>
            private static string CronExpressionString;

            /// <summary>
            /// Skips the white space.
            /// </summary>
            /// <param name="i">The i.</param>
            /// <param name="s">The s.</param>
            /// <returns></returns>
            private static int SkipWhiteSpace(int i, string s)
            {
                for (; i < s.Length && (s[i] == ' ' || s[i] == '\t'); i++)
                {
                }

                return i;
            }

            /// <summary>
            /// Finds the next white space.
            /// </summary>
            /// <param name="i">The i.</param>
            /// <param name="s">The s.</param>
            /// <returns></returns>
            private static int FindNextWhiteSpace(int i, string s)
            {
                for (; i < s.Length && (s[i] != ' ' || s[i] != '\t'); i++)
                {
                }

                return i;
            }

            /// <summary>
            /// Adds to set.
            /// </summary>
            /// <param name="val">The val.</param>
            /// <param name="end">The end.</param>
            /// <param name="incr">The incr.</param>
            /// <param name="type">The type.</param>
            private void AddToSet(int val, int end, int incr, int type)
            {
                var data = GetSet(type);

                if (type == Second || type == Minute)
                {
                    if ((val < 0 || val > 59 || end > 59) && val != AllSpecInt)
                    {
                        throw new FormatException("分钟和秒值必须介于0和59之间");
                    }
                }
                else if (type == Hour)
                {
                    if ((val < 0 || val > 23 || end > 23) && val != AllSpecInt)
                    {
                        throw new FormatException("小时值必须介于0和23之间");
                    }
                }
                else if (type == DayOfMonth)
                {
                    if ((val < 1 || val > 31 || end > 31) && val != AllSpecInt
                        && val != NoSpecInt)
                    {
                        throw new FormatException("月日值必须介于1和31之间");
                    }
                }
                else if (type == Month)
                {
                    if ((val < 1 || val > 12 || end > 12) && val != AllSpecInt)
                    {
                        throw new FormatException("月份值必须介于1和12之间");
                    }
                }
                else if (type == DayOfWeek)
                {
                    if ((val == 0 || val > 7 || end > 7) && val != AllSpecInt
                        && val != NoSpecInt)
                    {
                        throw new FormatException("星期日值必须介于1和7之间");
                    }
                }

                if ((incr == 0 || incr == -1) && val != AllSpecInt)
                {
                    if (val != -1)
                    {
                        data.Add(val);
                    }
                    else
                    {
                        data.Add(NoSpec);
                    }
                    return;
                }

                int startAt = val;
                int stopAt = end;

                if (val == AllSpecInt && incr <= 0)
                {
                    incr = 1;
                    data.Add(AllSpec);
                }

                if (type == Second || type == Minute)
                {
                    if (stopAt == -1)
                    {
                        stopAt = 59;
                    }
                    if (startAt == -1 || startAt == AllSpecInt)
                    {
                        startAt = 0;
                    }
                }
                else if (type == Hour)
                {
                    if (stopAt == -1)
                    {
                        stopAt = 23;
                    }
                    if (startAt == -1 || startAt == AllSpecInt)
                    {
                        startAt = 0;
                    }
                }
                else if (type == DayOfMonth)
                {
                    if (stopAt == -1)
                    {
                        stopAt = 31;
                    }
                    if (startAt == -1 || startAt == AllSpecInt)
                    {
                        startAt = 1;
                    }
                }
                else if (type == Month)
                {
                    if (stopAt == -1)
                    {
                        stopAt = 12;
                    }
                    if (startAt == -1 || startAt == AllSpecInt)
                    {
                        startAt = 1;
                    }
                }
                else if (type == DayOfWeek)
                {
                    if (stopAt == -1)
                    {
                        stopAt = 7;
                    }
                    if (startAt == -1 || startAt == AllSpecInt)
                    {
                        startAt = 1;
                    }
                }
                else if (type == Year)
                {
                    if (stopAt == -1)
                    {
                        stopAt = MaxYear;
                    }
                    if (startAt == -1 || startAt == AllSpecInt)
                    {
                        startAt = 1970;
                    }
                }

                int max = -1;
                if (stopAt < startAt)
                {
                    switch (type)
                    {
                        case Second:
                            max = 60;
                            break;
                        case Minute:
                            max = 60;
                            break;
                        case Hour:
                            max = 24;
                            break;
                        case Month:
                            max = 12;
                            break;
                        case DayOfWeek:
                            max = 7;
                            break;
                        case DayOfMonth:
                            max = 31;
                            break;
                        case Year:
                            throw new ArgumentException("开始年份必须小于停止年份");
                        default:
                            throw new ArgumentException("遇到意外的类型");
                    }
                    stopAt += max;
                }

                for (int i = startAt; i <= stopAt; i += incr)
                {
                    if (max == -1)
                    {
                        data.Add(i);
                    }
                    else
                    {
                        int i2 = i % max;
                        if (i2 == 0 && (type == Month || type == DayOfWeek || type == DayOfMonth))
                        {
                            i2 = max;
                        }

                        data.Add(i2);
                    }
                }
            }

            /// <summary>
            /// Gets the set of given type.
            /// </summary>
            /// <param name="type">The type of set to get.</param>
            /// <returns></returns>
            private SortedSet<int> GetSet(int type)
            {
                switch (type)
                {
                    case Second:
                        return seconds;
                    case Minute:
                        return minutes;
                    case Hour:
                        return hours;
                    case DayOfMonth:
                        return daysOfMonth;
                    case Month:
                        return months;
                    case DayOfWeek:
                        return daysOfWeek;
                    case Year:
                        return years;
                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }

            /// <summary>
            /// Gets the value.
            /// </summary>
            /// <param name="v">The v.</param>
            /// <param name="s">The s.</param>
            /// <param name="i">The i.</param>
            /// <returns></returns>
            private static ValueSet GetValue(int v, string s, int i)
            {
                char c = s[i];
                StringBuilder s1 = new StringBuilder(v.ToString(CultureInfo.InvariantCulture));
                while (c >= '0' && c <= '9')
                {
                    s1.Append(c);
                    i++;
                    if (i >= s.Length)
                    {
                        break;
                    }
                    c = s[i];
                }
                ValueSet val = new ValueSet();
                if (i < s.Length)
                {
                    val.pos = i;
                }
                else
                {
                    val.pos = i + 1;
                }
                val.theValue = Convert.ToInt32(s1.ToString(), CultureInfo.InvariantCulture);
                return val;
            }

            /// <summary>
            /// Gets the numeric value from string.
            /// </summary>
            /// <param name="s">The string to parse from.</param>
            /// <param name="i">The i.</param>
            /// <returns></returns>
            private static int GetNumericValue(string s, int i)
            {
                int endOfVal = FindNextWhiteSpace(i, s);
                string val = s.Substring(i, endOfVal - i);
                return Convert.ToInt32(val, CultureInfo.InvariantCulture);
            }

            /// <summary>
            /// Gets the month number.
            /// </summary>
            /// <param name="s">The string to map with.</param>
            /// <returns></returns>
            private static int GetMonthNumber(string s)
            {
                if (monthMap.ContainsKey(s))
                {
                    return monthMap[s];
                }

                return -1;
            }

            /// <summary>
            /// Gets the day of week number.
            /// </summary>
            /// <param name="s">The s.</param>
            /// <returns></returns>
            private static int GetDayOfWeekNumber(string s)
            {
                if (dayMap.ContainsKey(s))
                {
                    return dayMap[s];
                }

                return -1;
            }

            /// <summary>
            /// 在给定时间之后获取下一个触发时间。
            /// </summary>
            /// <param name="afterTimeUtc">开始搜索的 UTC 时间。</param>
            /// <returns></returns>
            public DateTimeOffset? GetTimeAfter(DateTimeOffset afterTimeUtc)
            {
                // 向前移动一秒钟，因为我们正在计算时间*之后*
                afterTimeUtc = afterTimeUtc.AddSeconds(1);

                // CronTrigger 不处理毫秒
                DateTimeOffset d = CreateDateTimeWithoutMillis(afterTimeUtc);

                // 更改为指定时区
                d = TimeZoneInfo.ConvertTime(d, timeZoneInfo);

                bool gotOne = false;
                //循环直到我们计算出下一次，或者我们已经过了 endTime
                while (!gotOne)
                {
                    SortedSet<int> st;
                    int t;
                    int sec = d.Second;

                    st = seconds.GetViewBetween(sec, 9999999);
                    if (st.Count > 0)
                    {
                        sec = st.First();
                    }
                    else
                    {
                        sec = seconds.First();
                        d = d.AddMinutes(1);
                    }
                    d = new DateTimeOffset(d.Year, d.Month, d.Day, d.Hour, d.Minute, sec, d.Millisecond, d.Offset);

                    int min = d.Minute;
                    int hr = d.Hour;
                    t = -1;

                    st = minutes.GetViewBetween(min, 9999999);
                    if (st.Count > 0)
                    {
                        t = min;
                        min = st.First();
                    }
                    else
                    {
                        min = minutes.First();
                        hr++;
                    }
                    if (min != t)
                    {
                        d = new DateTimeOffset(d.Year, d.Month, d.Day, d.Hour, min, 0, d.Millisecond, d.Offset);
                        d = SetCalendarHour(d, hr);
                        continue;
                    }
                    d = new DateTimeOffset(d.Year, d.Month, d.Day, d.Hour, min, d.Second, d.Millisecond, d.Offset);

                    hr = d.Hour;
                    int day = d.Day;
                    t = -1;

                    st = hours.GetViewBetween(hr, 9999999);
                    if (st.Count > 0)
                    {
                        t = hr;
                        hr = st.First();
                    }
                    else
                    {
                        hr = hours.First();
                        day++;
                    }
                    if (hr != t)
                    {
                        int daysInMonth = DateTime.DaysInMonth(d.Year, d.Month);
                        if (day > daysInMonth)
                        {
                            d = new DateTimeOffset(d.Year, d.Month, daysInMonth, d.Hour, 0, 0, d.Millisecond, d.Offset).AddDays(day - daysInMonth);
                        }
                        else
                        {
                            d = new DateTimeOffset(d.Year, d.Month, day, d.Hour, 0, 0, d.Millisecond, d.Offset);
                        }
                        d = SetCalendarHour(d, hr);
                        continue;
                    }
                    d = new DateTimeOffset(d.Year, d.Month, d.Day, hr, d.Minute, d.Second, d.Millisecond, d.Offset);

                    day = d.Day;
                    int mon = d.Month;
                    t = -1;
                    int tmon = mon;

                    bool dayOfMSpec = !daysOfMonth.Contains(NoSpec);
                    bool dayOfWSpec = !daysOfWeek.Contains(NoSpec);
                    if (dayOfMSpec && !dayOfWSpec)
                    {
                        // 逐月获取规则
                        st = daysOfMonth.GetViewBetween(day, 9999999);
                        bool found = st.Any();
                        if (lastdayOfMonth)
                        {
                            if (!nearestWeekday)
                            {
                                t = day;
                                day = GetLastDayOfMonth(mon, d.Year);
                                day -= lastdayOffset;

                                if (t > day)
                                {
                                    mon++;
                                    if (mon > 12)
                                    {
                                        mon = 1;
                                        tmon = 3333; // 确保下面的 mon != tmon 测试失败
                                        d = d.AddYears(1);
                                    }
                                    day = 1;
                                }
                            }
                            else
                            {
                                t = day;
                                day = GetLastDayOfMonth(mon, d.Year);
                                day -= lastdayOffset;

                                DateTimeOffset tcal = new DateTimeOffset(d.Year, mon, day, 0, 0, 0, d.Offset);

                                int ldom = GetLastDayOfMonth(mon, d.Year);
                                DayOfWeek dow = tcal.DayOfWeek;

                                if (dow == System.DayOfWeek.Saturday && day == 1)
                                {
                                    day += 2;
                                }
                                else if (dow == System.DayOfWeek.Saturday)
                                {
                                    day -= 1;
                                }
                                else if (dow == System.DayOfWeek.Sunday && day == ldom)
                                {
                                    day -= 2;
                                }
                                else if (dow == System.DayOfWeek.Sunday)
                                {
                                    day += 1;
                                }

                                DateTimeOffset nTime = new DateTimeOffset(tcal.Year, mon, day, hr, min, sec, d.Millisecond, d.Offset);
                                if (nTime.ToUniversalTime() < afterTimeUtc)
                                {
                                    day = 1;
                                    mon++;
                                }
                            }
                        }
                        else if (nearestWeekday)
                        {
                            t = day;
                            day = daysOfMonth.First();

                            DateTimeOffset tcal = new DateTimeOffset(d.Year, mon, day, 0, 0, 0, d.Offset);

                            int ldom = GetLastDayOfMonth(mon, d.Year);
                            DayOfWeek dow = tcal.DayOfWeek;

                            if (dow == System.DayOfWeek.Saturday && day == 1)
                            {
                                day += 2;
                            }
                            else if (dow == System.DayOfWeek.Saturday)
                            {
                                day -= 1;
                            }
                            else if (dow == System.DayOfWeek.Sunday && day == ldom)
                            {
                                day -= 2;
                            }
                            else if (dow == System.DayOfWeek.Sunday)
                            {
                                day += 1;
                            }

                            tcal = new DateTimeOffset(tcal.Year, mon, day, hr, min, sec, d.Offset);
                            if (tcal.ToUniversalTime() < afterTimeUtc)
                            {
                                day = daysOfMonth.First();
                                mon++;
                            }
                        }
                        else if (found)
                        {
                            t = day;
                            day = st.First();

                            //确保我们不会在短时间内跑得过快，比如二月
                            int lastDay = GetLastDayOfMonth(mon, d.Year);
                            if (day > lastDay)
                            {
                                day = daysOfMonth.First();
                                mon++;
                            }
                        }
                        else
                        {
                            day = daysOfMonth.First();
                            mon++;
                        }

                        if (day != t || mon != tmon)
                        {
                            if (mon > 12)
                            {
                                d = new DateTimeOffset(d.Year, 12, day, 0, 0, 0, d.Offset).AddMonths(mon - 12);
                            }
                            else
                            {
                                //这是为了避免从一个月移动时出现错误
                                //有 30 或 31 天到一个月更少。 导致实例化无效的日期时间。
                                int lDay = DateTime.DaysInMonth(d.Year, mon);
                                if (day <= lDay)
                                {
                                    d = new DateTimeOffset(d.Year, mon, day, 0, 0, 0, d.Offset);
                                }
                                else
                                {
                                    d = new DateTimeOffset(d.Year, mon, lDay, 0, 0, 0, d.Offset).AddDays(day - lDay);
                                }
                            }
                            continue;
                        }
                    }
                    else if (dayOfWSpec && !dayOfMSpec)
                    {
                        // 获取星期几规则
                        if (lastdayOfWeek)
                        {

                            int dow = daysOfWeek.First();

                            int cDow = (int)d.DayOfWeek + 1;
                            int daysToAdd = 0;
                            if (cDow < dow)
                            {
                                daysToAdd = dow - cDow;
                            }
                            if (cDow > dow)
                            {
                                daysToAdd = dow + (7 - cDow);
                            }

                            int lDay = GetLastDayOfMonth(mon, d.Year);

                            if (day + daysToAdd > lDay)
                            {

                                if (mon == 12)
                                {

                                    d = new DateTimeOffset(d.Year, mon - 11, 1, 0, 0, 0, d.Offset).AddYears(1);
                                }
                                else
                                {
                                    d = new DateTimeOffset(d.Year, mon + 1, 1, 0, 0, 0, d.Offset);
                                }

                                continue;
                            }

                            // 查找本月这一天最后一次出现的日期...
                            while (day + daysToAdd + 7 <= lDay)
                            {
                                daysToAdd += 7;
                            }

                            day += daysToAdd;

                            if (daysToAdd > 0)
                            {
                                d = new DateTimeOffset(d.Year, mon, day, 0, 0, 0, d.Offset);

                                continue;
                            }
                        }
                        else if (nthdayOfWeek != 0)
                        {

                            int dow = daysOfWeek.First();

                            int cDow = (int)d.DayOfWeek + 1;
                            int daysToAdd = 0;
                            if (cDow < dow)
                            {
                                daysToAdd = dow - cDow;
                            }
                            else if (cDow > dow)
                            {
                                daysToAdd = dow + (7 - cDow);
                            }

                            bool dayShifted = daysToAdd > 0;

                            day += daysToAdd;
                            int weekOfMonth = day / 7;
                            if (day % 7 > 0)
                            {
                                weekOfMonth++;
                            }

                            daysToAdd = (nthdayOfWeek - weekOfMonth) * 7;
                            day += daysToAdd;
                            if (daysToAdd < 0 || day > GetLastDayOfMonth(mon, d.Year))
                            {
                                if (mon == 12)
                                {
                                    d = new DateTimeOffset(d.Year, mon - 11, 1, 0, 0, 0, d.Offset).AddYears(1);
                                }
                                else
                                {
                                    d = new DateTimeOffset(d.Year, mon + 1, 1, 0, 0, 0, d.Offset);
                                }

                                continue;
                            }
                            if (daysToAdd > 0 || dayShifted)
                            {
                                d = new DateTimeOffset(d.Year, mon, day, 0, 0, 0, d.Offset);

                                continue;
                            }
                        }
                        else if (everyNthWeek != 0)
                        {
                            int cDow = (int)d.DayOfWeek + 1;
                            int dow = daysOfWeek.First();

                            st = daysOfWeek.GetViewBetween(cDow, 9999999);
                            if (st.Count > 0)
                            {
                                dow = st.First();
                            }

                            int daysToAdd = 0;
                            if (cDow < dow)
                            {
                                daysToAdd = (dow - cDow) + (7 * (everyNthWeek - 1));
                            }
                            if (cDow > dow)
                            {
                                daysToAdd = (dow + (7 - cDow)) + (7 * (everyNthWeek - 1));
                            }


                            if (daysToAdd > 0)
                            {
                                d = new DateTimeOffset(d.Year, mon, day, 0, 0, 0, d.Offset);
                                d = d.AddDays(daysToAdd);
                                continue;
                            }
                        }
                        else
                        {
                            int cDow = (int)d.DayOfWeek + 1;
                            int dow = daysOfWeek.First();

                            st = daysOfWeek.GetViewBetween(cDow, 9999999);
                            if (st.Count > 0)
                            {
                                dow = st.First();
                            }

                            int daysToAdd = 0;
                            if (cDow < dow)
                            {
                                daysToAdd = dow - cDow;
                            }
                            if (cDow > dow)
                            {
                                daysToAdd = dow + (7 - cDow);
                            }

                            int lDay = GetLastDayOfMonth(mon, d.Year);

                            if (day + daysToAdd > lDay)
                            {

                                if (mon == 12)
                                {
                                    d = new DateTimeOffset(d.Year, mon - 11, 1, 0, 0, 0, d.Offset).AddYears(1);
                                }
                                else
                                {
                                    d = new DateTimeOffset(d.Year, mon + 1, 1, 0, 0, 0, d.Offset);
                                }
                                continue;
                            }
                            if (daysToAdd > 0)
                            {
                                d = new DateTimeOffset(d.Year, mon, day + daysToAdd, 0, 0, 0, d.Offset);
                                continue;
                            }
                        }
                    }
                    else
                    {
                        throw new FormatException("不支持同时指定星期日和月日参数。");
                    }

                    d = new DateTimeOffset(d.Year, d.Month, day, d.Hour, d.Minute, d.Second, d.Offset);
                    mon = d.Month;
                    int year = d.Year;
                    t = -1;


                    if (year > MaxYear)
                    {
                        return null;
                    }

                    st = months.GetViewBetween(mon, 9999999);
                    if (st.Count > 0)
                    {
                        t = mon;
                        mon = st.First();
                    }
                    else
                    {
                        mon = months.First();
                        year++;
                    }
                    if (mon != t)
                    {
                        d = new DateTimeOffset(year, mon, 1, 0, 0, 0, d.Offset);
                        continue;
                    }
                    d = new DateTimeOffset(d.Year, mon, d.Day, d.Hour, d.Minute, d.Second, d.Offset);
                    year = d.Year;
                    t = -1;

                    st = years.GetViewBetween(year, 9999999);
                    if (st.Count > 0)
                    {
                        t = year;
                        year = st.First();
                    }
                    else
                    {
                        return null;
                    }

                    if (year != t)
                    {
                        d = new DateTimeOffset(year, 1, 1, 0, 0, 0, d.Offset);
                        continue;
                    }
                    d = new DateTimeOffset(year, d.Month, d.Day, d.Hour, d.Minute, d.Second, d.Offset);

                    //为此日期应用适当的偏移量
                    d = new DateTimeOffset(d.DateTime, timeZoneInfo.BaseUtcOffset);

                    gotOne = true;
                }

                return d.ToUniversalTime();
            }

            /// <summary>
            /// Creates the date time without milliseconds.
            /// </summary>
            /// <param name="time">The time.</param>
            /// <returns></returns>
            private static DateTimeOffset CreateDateTimeWithoutMillis(DateTimeOffset time)
            {
                return new DateTimeOffset(time.Year, time.Month, time.Day, time.Hour, time.Minute, time.Second, time.Offset);
            }

            /// <summary>
            /// Advance the calendar to the particular hour paying particular attention
            /// to daylight saving problems.
            /// </summary>
            /// <param name="date">The date.</param>
            /// <param name="hour">The hour.</param>
            /// <returns></returns>
            private static DateTimeOffset SetCalendarHour(DateTimeOffset date, int hour)
            {
                int hourToSet = hour;
                if (hourToSet == 24)
                {
                    hourToSet = 0;
                }
                DateTimeOffset d = new DateTimeOffset(date.Year, date.Month, date.Day, hourToSet, date.Minute, date.Second, date.Millisecond, date.Offset);
                if (hour == 24)
                {
                    d = d.AddDays(1);
                }
                return d;
            }

            /// <summary>
            /// Gets the last day of month.
            /// </summary>
            /// <param name="monthNum">The month num.</param>
            /// <param name="year">The year.</param>
            /// <returns></returns>
            private static int GetLastDayOfMonth(int monthNum, int year)
            {
                return DateTime.DaysInMonth(year, monthNum);
            }

            private class ValueSet
            {
                public int theValue;

                public int pos;
            }
        }
    }
}

CronHelper 中 CronExpression 的函数计算逻辑是从 Quart.NET 借鉴的，支持标准的 7位 cron 表达式，在需要生成Cron 表达式时可以直接使用网络上的各种 Cron 表达式在线生成

CronHelper 里面我们主要用到的功能就是 通过 Cron 表达式，解析下一次的执行时间。

接下来看一下我这里写的一个DemoTask，代码如下：

using DistributedLock;
using Repository.Database;
using TaskService.Libraries;

namespace TaskService.Tasks
{
    public class DemoTask : BackgroundService
    {
        private readonly IServiceProvider serviceProvider;
        private readonly ILogger logger;

        public DemoTask(IServiceProvider serviceProvider, ILogger<DemoTask> logger)
        {
            this.serviceProvider = serviceProvider;
            this.logger = logger;
        }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            CronSchedule.BatchBuilder(stoppingToken, this);

            await Task.Delay(-1, stoppingToken);
        }

        [CronSchedule(Cron = "0/1 * * * * ?")]
        public void ClearLog()
        {
            try
            {
                using var scope = serviceProvider.CreateScope();
                var db = scope.ServiceProvider.GetRequiredService<DatabaseContext>();

                //省略业务代码
                Console.WriteLine("ClearLog:" + DateTime.Now);
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "DemoTask.ClearLog");
            }
        }

        [CronSchedule(Cron = "0/5 * * * * ?")]
        public void ClearCache()
        {
            try
            {
                using var scope = serviceProvider.CreateScope();
                var db = scope.ServiceProvider.GetRequiredService<DatabaseContext>();
                var distLock = scope.ServiceProvider.GetRequiredService<IDistributedLock>();

                //省略业务代码
                Console.WriteLine("ClearCache:" + DateTime.Now);
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "DemoTask.ClearCache");
            }
        }
    }
}

该Task中有两个方法 ClearLog 和 ClearCache 他们分别会每1秒和每5秒执行一次。需要注意在后台服务中对于 Scope 生命周期的服务在获取是需要手动 CreateScope()；

实现的关键点在于 服务执行 ExecuteAsync 中的 CronSchedule.BatchBuilder(stoppingToken, this); 我们这里将代码有 CronSchedule 标记头的方法全部循环进行了启动，该方法的代码如下：

using Common;
using System.Reflection;

namespace TaskService.Libraries
{
    public class CronSchedule
    {
　　　　 public static void BatchBuilder(CancellationToken stoppingToken, object context)
        {
            var taskList = context.GetType().GetMethods().Where(t => t.GetCustomAttributes(typeof(CronScheduleAttribute), false).Length > 0).ToList();

            foreach (var t in taskList)
            {
                string cron = t.CustomAttributes.Where(t => t.AttributeType == typeof(CronScheduleAttribute)).FirstOrDefault()!.NamedArguments.Where(t => t.MemberName == "Cron" && t.TypedValue.Value != null).Select(t => t.TypedValue.Value!.ToString()).FirstOrDefault()!;

                Builder(stoppingToken, cron, t, context);
            }
        }

        private static async void Builder(CancellationToken stoppingToken, string cronExpression, MethodInfo action, object context)
        {
            var nextTime = DateTime.Parse(CronHelper.GetNextOccurrence(cronExpression).ToString("yyyy-MM-dd HH:mm:ss"));

            while (!stoppingToken.IsCancellationRequested)
            {
                var nowTime = DateTime.Parse(DateTimeOffset.UtcNow.ToString("yyyy-MM-dd HH:mm:ss"));

                if (nextTime == nowTime)
                {
                    _ = Task.Run(() =>
                    {
                        action.Invoke(context, null);

                    });

                    nextTime = DateTime.Parse(CronHelper.GetNextOccurrence(cronExpression).ToString("yyyy-MM-dd HH:mm:ss"));
                }
                else if (nextTime < nowTime)
                {
                    nextTime = DateTime.Parse(CronHelper.GetNextOccurrence(cronExpression).ToString("yyyy-MM-dd HH:mm:ss"));
                }

                await Task.Delay(1000, stoppingToken);
            }
        }
    }

    [AttributeUsage(AttributeTargets.Method)]
    public class CronScheduleAttribute : Attribute
    {
        public string Cron { get; set; }
    }
}

主要就是利用反射获取当前类中所有带有 CronSchedule 标记的方法，然后解析对应的 Cron 表达式获取下一次的执行时间，如果执行时间等于当前时间则执行一次方法，否则等待1秒钟循环重复这个逻辑。

然后启动我们的项目就可以看到如下的运行效果：

  ClearLog 每1秒钟执行一次，ClearCache 每 5秒钟执行一次

这篇关于.NET 纯原生实现 Cron 定时任务执行，未依赖第三方组件的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！