/// <summary>
/// CronTrigger表达式配置
/// </summary>
/// <remarks>
/// CronTrigger配置格式:
/// 格式: [秒] [分] [小时] [日] [月] [周] [年]
/// 序号 说明 必填 允许填写的值 允许的通配符
/// 1 秒 是 0-59 , - * /
/// 2 分 是 0-59 , - * /
/// 3 小时 是 0-23 , - * /
/// 4 日 是 1-31 , - * ? / L W
/// 5 月 是 1-12 or JAN-DEC , - * /
/// 6 周 是 1-7 or SUN-SAT , - * ? / L #
/// 7 年 否 empty 或 1970-2099 , - * /
/// 通配符说明:
/// * 表示所有值. 例如:在分的字段上设置 "*",表示每一分钟都会触发。
/// ? 表示不指定值。使用的场景为不需要关心当前设置这个字段的值。例如:要在每月的10号触发一个操作,但不关心是周几,所以需要周位置的那个字段设置为"?" 具体设置为 0 0 0 10 * ?
/// - 表示区间。例如 在小时上设置 "10-12",表示 10,11,12点都会触发。
/// , 表示指定多个值,例如在周字段上设置 "MON,WED,FRI" 表示周一,周三和周五触发
/// / 用于递增触发。如在秒上面设置"5/15" 表示从5秒开始,每增15秒触发(5,20,35,50)。 在月字段上设置'1/3'所示每月1号开始,每隔三天触发一次。
/// L 表示最后的意思。在日字段设置上,表示当月的最后一天(依据当前月份,如果是二月还会依据是否是润年[leap]), 在周字段上表示星期六,相当于"7"或"SAT"。如果在"L"前加上数字,则表示该数据的最后一个。例如在周字段上设置"6L"这样的格式,则表示“本月最后一个星期五"
/// W 表示离指定日期的最近那个工作日(周一至周五). 例如在日字段上设置"15W",表示离每月15号最近的那个工作日触发。如果15号正好是周六,则找最近的周五(14号)触发, 如果15号是周未,则找最近的下周一(16号)触发.如果15号正好在工作日(周一至周五),则就在该天触发。如果指定格式为 "1W",它则表示每月1号往后最近的工作日触发。如果1号正是周六,则将在3号下周一触发。(注,"W"前只能设置具体的数字,不允许区间"-").
/// 小提示 'L'和 'W'可以一组合使用。如果在日字段上设置"LW",则表示在本月的最后一个工作日触发(一般指发工资 )
/// # 序号(表示每月的第几个周几),例如在周字段上设置"6#3"表示在每月的第三个周六.注意如果指定"#5",正好第五周没有周六,则不会触发该配置(用在母亲节和父亲节再合适不过了)
/// 小提示:周字段的设置,若使用英文字母是不区分大小写的 MON 与mon相同.
/// </remarks>
public class CronTriggerBuilder : IEnumerable<BaseCronCake>
{
/// <summary>
/// 列表存储
/// </summary>
private Dictionary<CronCakeCycle, BaseCronCake> dicCronCake = new Dictionary<CronCakeCycle, BaseCronCake>();
/// <summary>
/// 构造函数
/// </summary>
protected CronTriggerBuilder()
{
}
/// <summary>
/// 创建表达式配置实例
/// </summary>
/// <returns></returns>
public static CronTriggerBuilder Create()
{
return new CronTriggerBuilder();
}
/// <summary>
/// 获取表达式块
/// </summary>
/// <param name="cronCakeCycle">计划周期类型</param>
/// <returns>返回表达式块</returns>
public BaseCronCake this[CronCakeCycle cronCakeCycle]
{
get
{
return this.dicCronCake[cronCakeCycle];
}
}
/// <summary>
/// 新增表达式块
/// </summary>
/// <param name="cronCake"></param>
/// <returns></returns>
public CronTriggerBuilder WithCronCake(BaseCronCake cronCake)
{
if (dicCronCake.ContainsKey(cronCake.Key))
dicCronCake[cronCake.Key] = cronCake;
dicCronCake.Add(cronCake.Key, cronCake);
return this;
}
/// <summary>
/// 生成表达式
/// </summary>
/// <returns></returns>
internal string Build()
{
if (dicCronCake.Count <= 0)
return string.Empty;
IList<string> list = new List<string>();
BaseCronCake baseCronCake = dicCronCake.Values.First(p => p.Key == CronCakeCycle.Second);
if (baseCronCake != null)
list.Add(baseCronCake.Build());
baseCronCake = dicCronCake.Values.Single(p => p.Key == CronCakeCycle.Minute);
if (baseCronCake != null)
list.Add(baseCronCake.Build());
baseCronCake = dicCronCake.Values.Single(p => p.Key == CronCakeCycle.Hour);
if (baseCronCake != null)
list.Add(baseCronCake.Build());
baseCronCake = dicCronCake.Values.Single(p => p.Key == CronCakeCycle.Day);
if (baseCronCake != null)
list.Add(baseCronCake.Build());
baseCronCake = dicCronCake.Values.Single(p => p.Key == CronCakeCycle.Month);
if (baseCronCake != null)
list.Add(baseCronCake.Build());
baseCronCake = dicCronCake.Values.Single(p => p.Key == CronCakeCycle.Week);
if (baseCronCake != null)
list.Add(baseCronCake.Build());
baseCronCake = dicCronCake.Values.Single(p => p.Key == CronCakeCycle.Year);
if (baseCronCake != null)
list.Add(baseCronCake.Build());
return string.Join<string>(" ", list);
}
#region IEnumerable<BaseCronCake> 成员
public IEnumerator<BaseCronCake> GetEnumerator()
{
return dicCronCake.Values.GetEnumerator();
}
#endregion
#region IEnumerable 成员
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return dicCronCake.Values.GetEnumerator();
}
#endregion
}
/// <summary>
/// 基本的Cron表达式块
/// </summary>
public abstract class BaseCronCake
{
/// <summary>
/// 逗号
/// </summary>
public const char Comma = ',';
/// <summary>
/// 星号
/// </summary>
public const char Asterisk = '*';
/// <summary>
/// 折线
/// </summary>
public const char Broken = '-';
/// <summary>
/// 反斜杠
/// </summary>
public const char Backslash = '/';
/// <summary>
/// 问号
/// </summary>
public const char Question = '?';
/// <summary>
/// 要输出的字符串
/// </summary>
protected string printString = string.Empty;
/// <summary>
/// 构造函数
/// </summary>
protected BaseCronCake()
{
}
/// <summary>
/// 默认的通配符返回
/// </summary>
protected virtual string defaultWildcard
{
get
{
return Asterisk.ToString();
}
}
/// <summary>
/// 使用周期的方式
/// </summary>
/// <param name="startCycle">周期开始</param>
/// <param name="endCycle">周期结束</param>
public virtual void WithCycle(int startCycle, int endCycle)
{
checkCycle(startCycle, endCycle);
//使用周期的方式来处理表达式
printString = string.Concat(startCycle, Broken, endCycle);
}
/// <summary>
/// 校验循环周期的值
/// </summary>
/// <param name="startCycle">周期开始</param>
/// <param name="endCycle">周期结束</param>
protected virtual void checkCycle(int startCycle, int endCycle)
{
if (startCycle < 0 || endCycle < 0)
throw new ArgumentException("Parameter error ", "startCycle");
if (startCycle >= endCycle)
throw new ArgumentException("Parameter error ", "startCycle");
}
/// <summary>
/// 使用递增的方式
/// </summary>
/// <param name="start">开始</param>
/// <param name="interval">递增间隔</param>
public virtual void WithIncrease(int start, int interval)
{
printString = string.Concat(start, Backslash, interval);
}
/// <summary>
/// 校验递增的值
/// </summary>
/// <param name="start">开始</param>
/// <param name="interval">递增间隔</param>
protected virtual void checkIncrease(int start, int interval)
{
if (start < 0 || interval <= 0)
throw new ArgumentException("Parameter error ", "start");
}
/// <summary>
/// 使用指定的方式
/// </summary>
public virtual void WithSpecified(IEnumerable<int> ranage)
{
Array.Sort<int>(ranage.ToArray());
checkSpecified(ranage);
if (ranage.Count() == 1)
printString = ranage.First().ToString();
else
printString = string.Join<int>(Comma.ToString(), ranage);
}
/// <summary>
/// 校验指定的值
/// </summary>
/// <param name="ranage">要检验的列表</param>
protected virtual void checkSpecified(IEnumerable<int> ranage)
{
if (ranage.Count() <= 0)
throw new ArgumentException("Parameter error ", "ranage");
if (ranage.First() < 0)
throw new ArgumentException("Parameter error ", "ranage");
}
/// <summary>
/// 输出表达式
/// </summary>
/// <returns></returns>
public virtual string Build()
{
if (string.IsNullOrEmpty(printString))
printString = defaultWildcard;
return printString;
}
/// <summary>
/// 类型
/// </summary>
internal abstract CronCakeCycle Key { get; }
}
/// <summary>
/// 计划周期
/// </summary>
internal enum CronCakeCycle
{
/// <summary>
/// 秒
/// </summary>
Second = 1,
/// <summary>
/// 分钟
/// </summary>
Minute = 2,
/// <summary>
/// 小时
/// </summary>
Hour = 3,
/// <summary>
/// 天
/// </summary>
Day = 4,
/// <summary>
/// 周
/// </summary>
Week = 5,
/// <summary>
/// 月
/// </summary>
Month = 6,
/// <summary>
/// 年
/// </summary>
Year = 7,
}
/// <summary>
/// 秒
/// </summary>
public class SecondsCronCake : BaseCronCake
{
/// <summary>
/// 校验指定的值
/// </summary>
/// <param name="ranage">要检验的列表</param>
protected override void checkSpecified(IEnumerable<int> ranage)
{
base.checkSpecified(ranage);
int max = ranage.Last();
if (max > 60)
throw new ArgumentException("Parameter error ", "ranage");
}
/// <summary>
/// 类型
/// </summary>
internal override CronCakeCycle Key
{
get { return CronCakeCycle.Second; }
}
}
/// <summary>
/// 分钟
/// </summary>
public class MinuteCronCake : BaseCronCake
{
/// <summary>
/// 校验指定的值
/// </summary>
/// <param name="ranage">要检验的列表</param>
protected override void checkSpecified(IEnumerable<int> ranage)
{
base.checkSpecified(ranage);
int max = ranage.Last();
if (max > 60)
throw new ArgumentException("Parameter error ", "ranage");
}
/// <summary>
/// 类型
/// </summary>
internal override CronCakeCycle Key
{
get { return CronCakeCycle.Minute; }
}
}
/// <summary>
/// 小时
/// </summary>
public class HourCronCake : BaseCronCake
{
/// <summary>
/// 校验指定的值
/// </summary>
/// <param name="ranage">要检验的列表</param>
protected override void checkSpecified(IEnumerable<int> ranage)
{
base.checkSpecified(ranage);
int max = ranage.Last();
if (max > 24)
throw new ArgumentException("Parameter error ", "ranage");
}
/// <summary>
/// 类型
/// </summary>
internal override CronCakeCycle Key
{
get { return CronCakeCycle.Hour; }
}
}
/// <summary>
/// 天
/// </summary>
public class DayCronCake : BaseCronCake
{
/// <summary>
/// 校验指定的值
/// </summary>
/// <param name="ranage">要检验的列表</param>
protected override void checkSpecified(IEnumerable<int> ranage)
{
base.checkSpecified(ranage);
int max = ranage.Last();
if (max > 31)
throw new ArgumentException("Parameter error ", "ranage");
}
/// <summary>
/// 不指定
/// </summary>
public void WithNoSpecified()
{
printString = Question.ToString();
}
/// <summary>
/// 每月start号最近的工作日
/// </summary>
/// <param name="start">最近的天</param>
public void WithNearByWorkDay(int start)
{
printString = string.Concat(start, "W");
}
/// <summary>
/// 本月最后一天
/// </summary>
public void WithLastDay()
{
printString = "L";
}
/// <summary>
/// 类型
/// </summary>
internal override CronCakeCycle Key
{
get { return CronCakeCycle.Day; }
}
}
/// <summary>
/// 月
/// </summary>
public class MonthCronCake : BaseCronCake
{
/// <summary>
/// 校验指定的值
/// </summary>
/// <param name="ranage">要检验的列表</param>
protected override void checkSpecified(IEnumerable<int> ranage)
{
base.checkSpecified(ranage);
int max = ranage.Last();
if (max > 12)
throw new ArgumentException("Parameter error ", "ranage");
}
/// <summary>
/// 不指定
/// </summary>
public void WithNoSpecified()
{
printString = Question.ToString();
}
/// <summary>
/// 类型
/// </summary>
internal override CronCakeCycle Key
{
get { return CronCakeCycle.Month; }
}
}
/// <summary>
/// 周
/// </summary>
public class WeekCronCake : BaseCronCake
{
/// <summary>
/// 星期日
/// </summary>
public const int Sunday = 1;
/// <summary>
/// 星期一
/// </summary>
public const int Monday = 2;
/// <summary>
/// 星期二
/// </summary>
public const int Tuesday = 3;
/// <summary>
/// 星期三
/// </summary>
public const int Wednesday = 4;
/// <summary>
/// 星期四
/// </summary>
public const int Thursday = 5;
/// <summary>
/// 星期五
/// </summary>
public const int Friday = 6;
/// <summary>
/// 星期六
/// </summary>
public const int Saturday = 7;
/// <summary>
/// 校验指定的值
/// </summary>
/// <param name="ranage">要检验的列表</param>
protected override void checkSpecified(IEnumerable<int> ranage)
{
base.checkSpecified(ranage);
int max = ranage.Last();
if (max > 7)
throw new ArgumentException("Parameter error ", "ranage");
}
/// <summary>
/// 不指定
/// </summary>
public void WithNoSpecified()
{
printString = Question.ToString();
}
/// <summary>
/// 第start周的星期几
/// </summary>
/// <param name="start"></param>
/// <param name="week">星期</param>
public void WithWeekly(int start, int week)
{
if (start <= 0 || start > 4)
throw new ArgumentException("Parameter error ", "start");
if (week < Sunday || week > Saturday)
throw new ArgumentException("Parameter error ", "week");
printString = string.Concat(week, "#", start);
}
/// <summary>
/// 本月最后一个星期几
/// </summary>
/// <param name="week">星期</param>
public void WithLastWeekly(int week)
{
if (week < Sunday || week > Saturday)
throw new ArgumentException("Parameter error ", "week");
printString = string.Concat(week, "L");
}
/// <summary>
/// 类型
/// </summary>
internal override CronCakeCycle Key
{
get { return CronCakeCycle.Week; }
}
}
/// <summary>
/// 年
/// </summary>
public class YearCornCake : BaseCronCake
{
/// <summary>
/// 使用递增的方式
/// </summary>
/// <param name="start">开始</param>
/// <param name="interval">递增间隔</param>
public override void WithIncrease(int start, int interval)
{
throw new NotSupportedException("The method or operation is not implemented.");
}
/// <summary>
/// 类型
/// </summary>
internal override CronCakeCycle Key
{
get { return CronCakeCycle.Year; }
}
}