/// <summary>
/// 获取 Cron 表达式下一个发生时间
/// </summary>
/// <param name="expression"></param>
/// <param name="cronFormat"></param>
/// <returns></returns>
public static DateTime?GetCronNextOccurrence(string expression, CronFormat cronFormat = CronFormat.Standard)
{
// 解析 Cron 表达式
var cronExpression = CronExpression.Parse(expression, cronFormat);
// 获取下一个执行时间
var nextTime = cronExpression.GetNextOccurrence(DateTimeOffset.Now, TimeZoneInfo.Local);
return(nextTime?.DateTime);
}
public static string ToString(this CronExpression cronExpression, CronFormat cronFormat)
{
var cronExpressionString = cronExpression.ToString();
if (cronFormat == CronFormat.Standard)
{
// todo: removes seconds from string representation
return(cronExpressionString.Substring(2));
}
return(cronExpressionString);
}
public void RunAsCronJob(string cron, CronFormat format = CronFormat.Standard)
{
ITaskSchedule schedule = new CronSchedule(cron, format);
_optionsFactory += builder =>
{
if (builder.Schedule != null)
{
throw new ArgumentException("A schedule for this task has already been set.");
}
builder.Schedule = schedule;
};
if (_asyncAction != null)
{
_taskBucket.AddBackgroundTask(_asyncAction, _optionsFactory);
}
else
{
_taskBucket.AddBackgroundTask(_syncAction, _optionsFactory);
}
}
public static unsafe CronExpression Parse(string expression, CronFormat format)
{
if (string.IsNullOrEmpty(expression))
{
throw new ArgumentNullException(nameof(expression));
fixed(char *value = expression)
{
var pointer = value;
SkipWhiteSpaces(ref pointer);
CronExpression cronExpression;
if (Accept(ref pointer, '@'))
{
cronExpression = ParseMacro(ref pointer);
SkipWhiteSpaces(ref pointer);
if (cronExpression == null || !IsEndOfString(*pointer))
{
ThrowFormatException("Macro: Unexpected character '{0}' on position {1}.", *pointer, pointer - value);
}
return(cronExpression);
}
cronExpression = new CronExpression();
if (format == CronFormat.IncludeSeconds)
{
cronExpression._second = ParseField(CronField.Seconds, ref pointer, ref cronExpression._flags);
ParseWhiteSpace(CronField.Seconds, ref pointer);
}
else
{
SetBit(ref cronExpression._second, CronField.Seconds.First);
}
cronExpression._minute = ParseField(CronField.Minutes, ref pointer, ref cronExpression._flags);
ParseWhiteSpace(CronField.Minutes, ref pointer);
cronExpression._hour = (int)ParseField(CronField.Hours, ref pointer, ref cronExpression._flags);
ParseWhiteSpace(CronField.Hours, ref pointer);
cronExpression._dayOfMonth = (int)ParseDayOfMonth(ref pointer, ref cronExpression._flags, ref cronExpression._lastMonthOffset);
ParseWhiteSpace(CronField.DaysOfMonth, ref pointer);
cronExpression._month = (short)ParseField(CronField.Months, ref pointer, ref cronExpression._flags);
ParseWhiteSpace(CronField.Months, ref pointer);
cronExpression._dayOfWeek = (byte)ParseDayOfWeek(ref pointer, ref cronExpression._flags, ref cronExpression._nthdayOfWeek);
ParseEndOfString(ref pointer);
// Make sundays equivalent.
if ((cronExpression._dayOfWeek & SundayBits) != 0)
{
cronExpression._dayOfWeek |= SundayBits;
}
return(cronExpression);
}
}
/// <summary>
/// Initializes new instances of <see cref="MilvaCronJobService"/>
/// </summary>
/// <param name="cronExpression"></param>
/// <param name="timeZoneInfo"></param>
/// <param name="cronFormat"></param>
protected MilvaCronJobService(string cronExpression, TimeZoneInfo timeZoneInfo, CronFormat cronFormat)
{
_expression = CronExpression.Parse(cronExpression, cronFormat);
_timeZoneInfo = timeZoneInfo;
}
public CronTrigger(string expression, CronFormat format, TimeSpan fireOffset)
: this(CronExpression.Parse(expression, format), fireOffset)
{
}
public CronTrigger(string expression, CronFormat format)
: this(CronExpression.Parse(expression, format), TimeSpan.Zero)
{
}
/// <summary>
/// 开始执行 Cron 表达式任务
/// </summary>
/// <param name="expression">Cron 表达式</param>
/// <param name="doWhat"></param>
/// <param name="workerName"></param>
/// <param name="description"></param>
/// <param name="startNow"></param>
/// <param name="cancelInNoneNextTime"></param>
/// <param name="cronFormat">配置 Cron 表达式格式化</param>
/// <param name="executeType"></param>
public static void Do(string expression, Action <SpareTimer, long> doWhat = default, string workerName = default, string description = default, bool startNow = true, bool cancelInNoneNextTime = true, CronFormat cronFormat = CronFormat.Standard, SpareTimeExecuteTypes executeType = SpareTimeExecuteTypes.Parallel)
{
Do(() => GetCronNextOccurrence(expression, cronFormat), doWhat, workerName, description, startNow, cancelInNoneNextTime, executeType);
}
/// <summary>
/// 开始 Cron 表达式任务（持续的）
/// <para>用于 Worker Services</para>
/// </summary>
/// <param name="expression"></param>
/// <param name="doWhat"></param>
/// <param name="stoppingToken"></param>
/// <param name="cronFormat"></param>
/// <returns></returns>
public static Task DoAsync(string expression, Action doWhat, CancellationToken stoppingToken, CronFormat cronFormat = CronFormat.Standard)
{
return(DoAsync(() => GetCronNextOccurrence(expression, cronFormat), doWhat, stoppingToken));
}
protected CronJobService(ILogger <CronJobService> logger, string cronExpression, TimeZoneInfo timeZoneInfo, CronFormat cronFormat = CronFormat.Standard)
{
_cronExpression = cronExpression;
_expression = CronExpression.Parse(cronExpression, cronFormat);
_logger = logger;
_timeZoneInfo = timeZoneInfo;
}
public static CronExpression Parse(string expression, TimeSpan offset, CronFormat format)
{
string[] expressions = expression.Split(new[] { ExpressionSeperator }, StringSplitOptions.RemoveEmptyEntries);
IRange nanoseconds;
IRange microseconds;
IRange milliseconds;
IRange seconds;
IRange minutes;
IRange hours;
IDayRange daysOfMonth;
IRange months;
IDayRange daysOfWeek;
IRange years;
if (format == CronFormat.Extended)
{
if (expressions.Length != 9 && expressions.Length != 10)
{
throw new ArgumentException();
}
nanoseconds = ParseRange(expressions[0], 100, 0, 900);
microseconds = ParseRange(expressions[1], 1, 0, 999);
milliseconds = ParseRange(expressions[2], 1, 0, 999);
seconds = ParseRange(expressions[3], 1, 0, 59);
minutes = ParseRange(expressions[4], 1, 0, 59);
hours = ParseRange(expressions[5], 1, 0, 23);
daysOfMonth = ParseRangeDayOfMonth(expressions[6]);
months = ParseRangeMonth(expressions[7]);
daysOfWeek = ParseRangeDayOfWeek(expressions[8]);
years = expressions.Length == 10 ? ParseRange(expressions[9], 1, DateTimeOffset.MinValue.Year, DateTimeOffset.MaxValue.Year) : null;
return new CronExpression(nanoseconds, microseconds, milliseconds, seconds, minutes, hours, daysOfMonth, months, daysOfWeek, years, offset);
}
if (expressions.Length != 6 && expressions.Length != 7)
{
throw new ArgumentException();
}
nanoseconds = new ImplicitRange(100, 0, 0);
microseconds = new ImplicitRange(1, 0, 0);
milliseconds = new ImplicitRange(1, 0, 0);
seconds = ParseRange(expressions[0], 1, 0, 59);
minutes = ParseRange(expressions[1], 1, 0, 59);
hours = ParseRange(expressions[2], 1, 0, 23);
daysOfMonth = ParseRangeDayOfMonth(expressions[3]);
months = ParseRangeMonth(expressions[4]);
daysOfWeek = ParseRangeDayOfWeek(expressions[5]);
years = expressions.Length == 7 ? ParseRange(expressions[6], 1, DateTimeOffset.MinValue.Year, DateTimeOffset.MaxValue.Year) : null;
return new CronExpression(nanoseconds, microseconds, milliseconds, seconds, minutes, hours, daysOfMonth, months, daysOfWeek, years, offset);
}
public static CronExpression Parse(string expression, CronFormat format)
{
return Parse(expression, DateTimeOffset.Now.Offset, format);
}
public CronSchedule(string cron, CronFormat format = CronFormat.Standard)
{
_cronSchedule = CronExpression.Parse(cron, format);
}
