您的程序支持复杂的时间调度嘛

你的程序支持复杂的时间调度嘛？

时隔两个月了，这段时间，游戏筹备正式上线，根据游戏平台数据反馈，反响还不错。

但是牵涉出新问题，就是活动。活动功能本身很简单。问题就在于，时间配置上，什么时间段开发活动。

配置多种多样。比如，没做星期2,4,6活动。每周的周六，周日，活动。指定月份和日期的活动。配置简直是天花乱坠了。。。这尼玛怎么搞？？？？

那么有么有万能的配置方式呢？首先，我能想到的配置肯定是字符串格式的。

必须包含，年月日星期时间，这尼玛不就犯难了嘛？？？？我们C#的 DateTime 类型格式化只支持年月日，时分秒啊。星期怎么控制？？？例如，我要每个星期的星期天搞一个活动，拉一拉充值消费我擦。。。

我自己都把自己绕晕了。。好吧。。。

后来想到一种方式，

[年][月][日][星期][时间]

[*][*][*][*][*]

这样利于分割，配置，清晰。

然后就是验证，时间在不在配置的时间开发内？

当然想到的*肯定是默认支持所有的

[2015][7][*][*][10:00-11:59]

这个格式，表示2015年的7月每一天的10点到12点为配置开启时间

[2015][7-9][*][*][10:00-11:59]

这个格式，表示2015年的7月1日到9月30的每一天的10点到12点为配置开启时间

[2015][7/9][*][*][10:00-11:59]

这个格式，表示2015年的7月或者9月的每一天的10点到12点为配置开启时间

[2015][*][*][2/4/6][10:00-11:59]
这个格式，表示2015年的每一个星期2，星期4，星期6 的每一天的10点到12点为配置开启时间

接下来，就是验证这个时间格式。

 1         #region 验证当前时间 年，月，日，星期，是否符合 static bool VerifyDate(int nowItem, string items)
 2         /// <summary>
 3         /// 验证当前时间 年，月，日，星期，是否符合
 4         /// </summary>
 5         /// <param name="items">1-7;表示 1 到 7 , 1/7 表示 1 或者 7</param>
 6         /// <returns></returns>
 7         static bool VerifyDate(int nowItem, string items)
 8         {
 9             string nowItemStr = nowItem.ToString();
10             if ("*".Equals(items) || nowItemStr.Equals(items)) { return true; }
11             else if (items.IndexOf("-") > 0)
12             {//区间划分
13                 string[] itemSplit = items.Split('-');
14                 int item1 = 9999;
15                 int.TryParse(itemSplit[0], out item1);
16                 int item2 = 9999;
17                 int.TryParse(itemSplit[1], out item2);
18 
19                 if (item1 <= nowItem && nowItem <= item2) { return true; }
20             }
21             else if (items.IndexOf("/") > 0)
22             {//或划分
23                 string[] weeksSplit = items.Split('/');
24                 foreach (var item in weeksSplit)
25                 {
26                     if (nowItemStr.Equals(item)) { return true; }
27                 }
28             }
29             return false;
30         }
31         #endregion
32 
33         #region 验证当期时间格式 static bool VerifyTime(DateTime date, string itemTime)
34         /// <summary>
35         /// 验证当期时间格式
36         /// </summary>
37         /// <param name="date"></param>
38         /// <param name="itemTime"></param>
39         /// <returns></returns>
40         static bool VerifyTime(DateTime date, string itemTime)
41         {
42             bool ret = false;
43             if (!"*".Equals(itemTime))
44             {
45                 var items = Regex.Split(itemTime, @"/");
46                 foreach (var item in items)
47                 {
48                     string[] itemTimes = item.Split('-');
49                     var hhmm = Regex.Split(itemTimes[0], @":|：");
50                     int hh = 24;
51                     int.TryParse(hhmm[0], out hh);
52                     int mm = 60;
53                     int.TryParse(hhmm[1], out mm);
54                     if (date.Hour > hh || (date.Hour == hh && date.Minute >= mm))
55                     {
56                         if (itemTimes.Length > 1)
57                         {
58                             var hhmm1 = Regex.Split(itemTimes[1], @":|：");
59                             int hh1 = 24;
60                             int.TryParse(hhmm1[0], out hh1);
61                             int mm1 = 60;
62                             int.TryParse(hhmm1[1], out mm1);
63                             if (date.Hour < hh1 || (date.Hour == hh1 && date.Minute < mm1)) { ret = true; }
64                             else { ret = false; }
65                         }
66                         else { ret = true; }
67                     }
68                     else { ret = false; }
69                     if (ret)
70                     {
71                         break;
72                     }
73                 }
74             }
75             else { ret = true; }
76             return ret;
77         }
78         #endregion

看看结果您的程序支持复杂的时间调度嘛

这样挺万能的吧？

如果每一天有两档活动开放

[2015][7][*][*][10:00-11:59/14:00-16:59]

您的程序支持复杂的时间调度嘛

当我完成了这个需求的时候，，新的需求又来了，，，妈蛋，，，需要倒计时，，活动还有多长时间开始。。

卧槽。。

好吧，，有需求就是大爷。。只能苦逼的程序去搞定了，需求一句话，我却花了一天时间啊。。。

我的思路是分解出，所包含的年月日，时间段开始。

 1         #region 获取配置的年月日星期等信息 static List<int> GetConfigDate(DateTime date, int p1, string p3)
 2         /// <summary>
 3         /// 获取配置的年月日星期等信息
 4         /// </summary>
 5         /// <param name="date"></param>
 6         /// <param name="p1"></param>
 7         /// <param name="p3"></param>
 8         /// <returns></returns>
 9         static List<int> GetConfigDate(DateTime date, int p1, string p3)
10         {
11             List<int> rets = new List<int>();
12             string p1Str = p1.ToString();
13             if ("*".Equals(p3) || p1Str.Equals(p3))
14             {
15                 rets.Add(p1);
16                 rets.Add(p1 + 1);
17             }
18             else if (p3.IndexOf("-") > 0)
19             {
20                 string[] weekSplit = p3.Split('-');
21                 int week1 = 9999;
22                 int.TryParse(weekSplit[0], out week1);
23 
24                 int week2 = 9999;
25                 int.TryParse(weekSplit[1], out week2);
26                 for (int i = week1; i < week2 + 1; i++)
27                 {
28                     rets.Add(i);
29                 }
30             }
31             else if (p3.IndexOf("/") > 0)
32             {
33                 string[] weeksSplit = p3.Split('/');
34                 foreach (var item in weeksSplit)
35                 {
36                     int temp = 0;
37                     if (int.TryParse(item, out temp))
38                     {
39                         rets.Add(temp);
40                     }
41                 }
42             }
43             else
44             {
45                 int temp = 0;
46                 if (int.TryParse(p3, out temp))
47                 {
48                     rets.Add(temp);
49                 }
50             }
51             return rets;
52         }
53         #endregion
54 
55         #region 获取配置的时间字符串 static List<string> GetConfigTimeStr(string itemTime)
56         /// <summary>
57         /// 获取配置的时间字符串 
58         /// </summary>
59         /// <param name="itemTime">必须类似的格式 单条 00:00-23:59  多条00:00-23:59/00:00-23:59</param>
60         /// <returns></returns>
61         static List<string> GetConfigTimeStr(string itemTime)
62         {
63             List<string> retObjs = new List<string>();
64             // 00:00-23:59
65             if (!"*".Equals(itemTime))
66             {
67                 var items = Regex.Split(itemTime, @"/");
68                 foreach (var item in items)
69                 {
70                     string[] itemTimes = item.Split('-');
71                     retObjs.Add(itemTimes[0]);
72                 }
73             }
74             else
75             {
76                 retObjs.Add("00:00");
77             }
78             return retObjs;
79         }
80         #endregion

这里有一个蛋疼的问题，就是包含了星期，那么无疑与日期就要牵涉跨星期跨月，跨年了，

您的程序支持复杂的时间调度嘛

在这里特别鸣谢兄弟帮忙的分析。。

所以我分析出来，检查包含的年月日来构造datetime 然后完成7天构造器。来分析时间段。

如果是本月那么就从当前的日期开始，如果不是本月那么就从1号开始，

 1         #region 处理星期包含的日期 日  static void ActionWeekDay(int weekmin, int weekmax, ref List<int> days, ref List<int> months, ref List<int> years)
 2         /// <summary>
 3         /// 处理星期包含的日期 日
 4         /// </summary>
 5         /// <param name="weekmin"></param>
 6         /// <param name="weekmax"></param>
 7         /// <param name="days"></param>
 8         /// <param name="months"></param>
 9         /// <param name="years"></param>
10         static void ActionWeekDay(int weekmin, int weekmax, ref List<int> days, ref List<int> months, ref List<int> years)
11         {
12             DateTime nowWeekDate = DateTime.Now;
13             List<int> tempDays, tempMonths, tempYears;
14             tempYears = years.ToList();
15             tempMonths = months.ToList();
16             tempDays = days.ToList();
17             foreach (var itemYear in tempYears)
18             {
19                 foreach (var itemMonth in tempMonths)
20                 {
21                     int itemDay = 1;
22                     if (nowWeekDate.Month == itemMonth)
23                     {
24                         itemDay = nowWeekDate.Day;
25                     }
26                     DateTime date = new DateTime(itemYear, itemMonth, itemDay);
27                     for (int i = 0; i < 7; i++)
28                     {
29                         int week = (int)date.DayOfWeek;
30                         if (week == 0)
31                         {
32                             week = 7;
33                         }
34                         if (weekmin <= week && week <= weekmax)
35                         {
36                             if (!days.Contains(date.Day))
37                             {
38                                 days.Add(date.Day);
39                             }
40                             if (!months.Contains(date.Month))
41                             {
42                                 months.Add(date.Month);
43                             }
44                             if (!years.Contains(date.Year))
45                             {
46                                 years.Add(date.Year);
47                             }
48                         }
49                         date = date.AddDays(1);
50                     }
51                 }
52             }
53         }
54         #endregion

验证器

  1    #region 验证时间:[*][*][20/22][*][10:00-11:59/16:00-17:59] static public long VerifyDateTime(string timeStr)
  2         /// <summary>
  3         /// 验证时间:[*][*][20/22][*][10:00-11:59/16:00-17:59]
  4         /// <para>第一个是年，，第二个是月，第三个是日期，第四个是星期，第五个是时间，</para>
  5         /// <para>每一个参数，"-" 表示 到 如：“2015-2017”表示 2015 到 2017, "/"  表示 或者 如： “2015/2017”表示2015 或者 2017</para>
  6         /// <para>返回值 -1 表示永久过期，0 表示在时间规则内，大于 0 表示倒计时</para>
  7         /// </summary> 
  8         static public long VerifyDateTime(string timeStr)
  9         {
 10             var items = Regex.Split(timeStr, @";|；");
 11             items.Reverse();
 12             long ret = -1;
 13             DateTime date = DateTime.Now;
 14             foreach (var item in items)
 15             {
 16                 //验证时间匹配
 17                 if (VerifyConfigTimeStr(date, item))
 18                 {
 19                     ret = 0;
 20                     goto Lab_Exit;
 21                 }
 22                 //未通过时间匹配，检查返回剩余时间
 23                 List<string> strs = new List<string>();
 24                 string[] timeStrs = item.Split(new char[] { ']' });
 25                 for (int i = 0; i < timeStrs.Length - 1; i++)
 26                 {
 27                     string time = timeStrs[i].Replace("[", "");
 28                     strs.Add(time);
 29                 }
 30 
 31                 string times = strs[4];
 32                 string weeks = strs[3];
 33                 string days = strs[2];
 34                 string months = strs[1];
 35                 string years = strs[0];
 36 
 37                 int hour = 0, minute = 0, second = 0;
 38                 var tempYears = GetConfigDate(date, date.Year, years);
 39                 var tempMonths = GetConfigDate(date, date.Month, months);
 40                 var tempDays = GetConfigDate(date, date.Day, days);
 41                 //由于星期比较特殊所以获取与星期相关的日期的时候有点诡异。
 42                 if (!"*".Equals(weeks))
 43                 {
 44                     if (weeks.IndexOf("-") > 0)
 45                     {
 46                         //星期的间隔模式
 47                         string[] weekSplit = weeks.Split('-');
 48                         int weekmin = 9999;
 49                         int.TryParse(weekSplit[0], out weekmin);
 50                         int weekmax = 9999;
 51                         int.TryParse(weekSplit[1], out weekmax);
 52                         ActionWeekDay(weekmin, weekmax, ref tempDays, ref tempMonths, ref tempYears);
 53                     }
 54                     else if (weeks.IndexOf("/") > 0)
 55                     {
 56                         //星期的或模式
 57                         string[] weeksSplit = weeks.Split('/');
 58                         int tempWeek;
 59                         if (int.TryParse(weeksSplit[0], out tempWeek))
 60                         {
 61                             if (0 <= tempWeek && tempWeek <= 7)
 62                             {
 63                                 ActionWeekDay(tempWeek, tempWeek, ref tempDays, ref tempMonths, ref tempYears);
 64                             }
 65                         }
 66                     }
 67                     else
 68                     {
 69                         //特定星期的模式
 70                         int tempweek = 0;
 71                         if (int.TryParse(weeks, out tempweek))
 72                         {
 73                             ActionWeekDay(tempweek, tempweek, ref tempDays, ref tempMonths, ref tempYears);
 74                         }
 75                     }
 76                 }
 77                 else
 78                 {
 79                     //未指定星期的模式
 80                     ActionWeekDay(1, 7, ref tempDays, ref tempMonths, ref tempYears);
 81                 }
 82 
 83                 var tempHHMMs = GetConfigTimeStr(times);
 84 
 85                 //进行简单的排序
 86                 tempYears.Sort();
 87                 tempMonths.Sort();
 88                 tempDays.Sort();
 89                 tempHHMMs.Sort();
 90 
 91                 //接下来这里是天坑，就是构造时间器比较，然后计算出倒计时
 92                 for (int y = 0; y < tempYears.Count; y++)
 93                 {
 94                     for (int m = 0; m < tempMonths.Count; m++)
 95                     {
 96                         for (int d = 0; d < tempDays.Count; d++)
 97                         {
 98                             for (int h = 0; h < tempHHMMs.Count; h++)
 99                             {
100                                 string[] hhmm = Regex.Split(tempHHMMs[h], ":|：");
101                                 if (int.TryParse(hhmm[0], out hour) && int.TryParse(hhmm[1], out minute))
102                                 {
103                                     DateTime actionTime = new DateTime(tempYears[y], tempMonths[m], tempDays[d], hour, minute, second);
104                                     if (actionTime > date)
105                                     {
106                                         if (VerifyConfigTimeStr(actionTime, item))
107                                         {
108                                             Console.WriteLine(actionTime.ToString("yyyy-MM-dd HH:mm:ss"));
109                                             TimeSpan ts = (actionTime - date);
110                                             ret = ts.Days * 24 * 60 * 60 + ts.Hours * 60 * 60 + ts.Minutes * 60 + ts.Seconds;
111                                             ret *= 1000;
112                                             ret += ts.Milliseconds;
113                                             goto Lab_Exit;
114                                         }
115                                     }
116                                 }
117                             }
118                         }
119                     }
120                 }
121             }
122         Lab_Exit:
123             return ret;
124         }
125         #endregion

验证活动配置时间

[2016][2][*][*][10:00-11:59/14:00-16:59]

您的程序支持复杂的时间调度嘛

接下来我们在测试一下性能问题，

您的程序支持复杂的时间调度嘛

大家都懂的，在控制台输出打印是比较耗时的，这种情况下2000次也才1秒；效率是不必是说的。

全部完整代码。。

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Linq;
  4 using System.Text;
  5 using System.Text.RegularExpressions;
  6 using System.Threading.Tasks;
  7 
  8 /**
  9  * 
 10  * @author 失足程序员
 11  * @Blog http://www.cnblogs.com/ty408/
 12  * @mail 492794628@qq.com
 13  * @phone 13882122019
 14  * 
 15  */
 16 namespace Sz
 17 {
 18     /// <summary>
 19     /// 时间验证器
 20     /// </summary>
 21     public static class TimeUtil
 22     {
 23 
 24         //static void Main(string[] args)
 25         //{
 26         //    Console.WriteLine("验证当期时间是否满足活动开放时间：[*][*][20/22][*][10:00-11:59/16:00-17:59]");
 27         //    System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
 28         //    watch.Restart();
 29         //    for (int i = 0; i < 5; i++)
 30         //    {
 31         //        long ticks = TimeUtil.VerifyDateTime("[2014/2016][9][*][*][10:00-11:59/16:00-22:59]");
 32         //        Console.WriteLine(ticks + " 倒计时：" + (ticks / 1000) + "秒");
 33         //    }
 34         //    watch.Stop();
 35         //    Console.WriteLine(watch.ElapsedMilliseconds);
 36         //    Console.ReadLine();
 37         //}
 38 
 39 
 40         /// <summary>
 41         /// 验证时间:[*][*][20/22][*][10:00-11:59/16:00-17:59]
 42         /// <para>第一个是年，，第二个是月，第三个是日期，第四个是星期，第五个是时间，</para>
 43         /// <para>每一个参数，"-" 表示 到 如：“2015-2017”表示 2015 到 2017, "/"  表示 或者 如： “2015/2017”表示2015 或者 2017</para>
 44         /// <para>返回值 -1 表示永久过期，0 表示在时间规则内，大于 0 表示倒计时</para>
 45         /// </summary> 
 46         static public long VerifyDateTime(string timeStr)
 47         {
 48             var items = Regex.Split(timeStr, @";|；");
 49             items.Reverse();
 50             long ret = -1;
 51             DateTime date = DateTime.Now;
 52             foreach (var item in items)
 53             {
 54                 //验证时间匹配
 55                 if (VerifyConfigTimeStr(date, item))
 56                 {
 57                     ret = 0;
 58                     goto Lab_Exit;
 59                 }
 60                 //未通过时间匹配，检查返回剩余时间
 61                 List<string> strs = new List<string>();
 62                 string[] timeStrs = item.Split(new char[] { ']' });
 63                 for (int i = 0; i < timeStrs.Length - 1; i++)
 64                 {
 65                     string time = timeStrs[i].Replace("[", "");
 66                     strs.Add(time);
 67                 }
 68 
 69                 string times = strs[4];
 70                 string weeks = strs[3];
 71                 string days = strs[2];
 72                 string months = strs[1];
 73                 string years = strs[0];
 74 
 75                 int hour = 0, minute = 0, second = 0;
 76                 var tempYears = GetConfigDate(date, date.Year, years);
 77                 var tempMonths = GetConfigDate(date, date.Month, months);
 78                 var tempDays = GetConfigDate(date, date.Day, days);
 79                 //由于星期比较特殊所以获取与星期相关的日期的时候有点诡异。
 80                 if (!"*".Equals(weeks))
 81                 {
 82                     if (weeks.IndexOf("-") > 0)
 83                     {
 84                         //星期的间隔模式
 85                         string[] weekSplit = weeks.Split('-');
 86                         int weekmin = 9999;
 87                         int.TryParse(weekSplit[0], out weekmin);
 88                         int weekmax = 9999;
 89                         int.TryParse(weekSplit[1], out weekmax);
 90                         ActionWeekDay(weekmin, weekmax, ref tempDays, ref tempMonths, ref tempYears);
 91                     }
 92                     else if (weeks.IndexOf("/") > 0)
 93                     {
 94                         //星期的或模式
 95                         string[] weeksSplit = weeks.Split('/');
 96                         int tempWeek;
 97                         if (int.TryParse(weeksSplit[0], out tempWeek))
 98                         {
 99                             if (0 <= tempWeek && tempWeek <= 7)
100                             {
101                                 ActionWeekDay(tempWeek, tempWeek, ref tempDays, ref tempMonths, ref tempYears);
102                             }
103                         }
104                     }
105                     else
106                     {
107                         //特定星期的模式
108                         int tempweek = 0;
109                         if (int.TryParse(weeks, out tempweek))
110                         {
111                             ActionWeekDay(tempweek, tempweek, ref tempDays, ref tempMonths, ref tempYears);
112                         }
113                     }
114                 }
115                 else
116                 {
117                     //未指定星期的模式
118                     ActionWeekDay(1, 7, ref tempDays, ref tempMonths, ref tempYears);
119                 }
120 
121                 var tempHHMMs = GetConfigTimeStr(times);
122 
123                 //进行简单的排序
124                 tempYears.Sort();
125                 tempMonths.Sort();
126                 tempDays.Sort();
127                 tempHHMMs.Sort();
128 
129                 //接下来这里是天坑，就是构造时间器比较，然后计算出倒计时
130                 for (int y = 0; y < tempYears.Count; y++)
131                 {
132                     for (int m = 0; m < tempMonths.Count; m++)
133                     {
134                         for (int d = 0; d < tempDays.Count; d++)
135                         {
136                             for (int h = 0; h < tempHHMMs.Count; h++)
137                             {
138                                 string[] hhmm = Regex.Split(tempHHMMs[h], ":|：");
139                                 if (int.TryParse(hhmm[0], out hour) && int.TryParse(hhmm[1], out minute))
140                                 {
141                                     DateTime actionTime = new DateTime(tempYears[y], tempMonths[m], tempDays[d], hour, minute, second);
142                                     if (actionTime > date)
143                                     {
144                                         if (VerifyConfigTimeStr(actionTime, item))
145                                         {
146                                             Console.WriteLine(actionTime.ToString("yyyy-MM-dd HH:mm:ss"));
147                                             TimeSpan ts = (actionTime - date);
148                                             ret = ts.Days * 24 * 60 * 60 + ts.Hours * 60 * 60 + ts.Minutes * 60 + ts.Seconds;
149                                             ret *= 1000;
150                                             ret += ts.Milliseconds;
151                                             goto Lab_Exit;
152                                         }
153                                     }
154                                 }
155                             }
156                         }
157                     }
158                 }
159             }
160         Lab_Exit:
161             return ret;
162         }
163 
164         #region 处理星期包含的日期 日  static void ActionWeekDay(int weekmin, int weekmax, ref List<int> days, ref List<int> months, ref List<int> years)
165         /// <summary>
166         /// 处理星期包含的日期 日
167         /// </summary>
168         /// <param name="weekmin"></param>
169         /// <param name="weekmax"></param>
170         /// <param name="days"></param>
171         /// <param name="months"></param>
172         /// <param name="years"></param>
173         static void ActionWeekDay(int weekmin, int weekmax, ref List<int> days, ref List<int> months, ref List<int> years)
174         {
175             DateTime nowWeekDate = DateTime.Now;
176             List<int> tempDays, tempMonths, tempYears;
177             tempYears = years.ToList();
178             tempMonths = months.ToList();
179             tempDays = days.ToList();
180             foreach (var itemYear in tempYears)
181             {
182                 foreach (var itemMonth in tempMonths)
183                 {
184                     int itemDay = 1;
185                     if (nowWeekDate.Month == itemMonth)
186                     {
187                         itemDay = nowWeekDate.Day;
188                     }
189                     DateTime date = new DateTime(itemYear, itemMonth, itemDay);
190                     for (int i = 0; i < 7; i++)
191                     {
192                         int week = (int)date.DayOfWeek;
193                         if (week == 0)
194                         {
195                             week = 7;
196                         }
197                         if (weekmin <= week && week <= weekmax)
198                         {
199                             if (!days.Contains(date.Day))
200                             {
201                                 days.Add(date.Day);
202                             }
203                             if (!months.Contains(date.Month))
204                             {
205                                 months.Add(date.Month);
206                             }
207                             if (!years.Contains(date.Year))
208                             {
209                                 years.Add(date.Year);
210                             }
211                         }
212                         date = date.AddDays(1);
213                     }
214                 }
215             }
216         }
217         #endregion
218 
219         #region 验证时间:[*][*][20/22][*][10:00-11:59/16:00-17:59] static bool VerifyConfigTimeStr(DateTime date, string timeStr)
220         /// <summary>
221         /// 验证时间:[*][*][20/22][*][10:00-11:59/16:00-17:59]
222         /// <para>第一个是年，，第二个是月，第三个是日期，第四个是星期，第五个是时间，</para>
223         /// <para>每一个参数，"-" 表示 到 如：“2015-2017”表示 2015 到 2017, "/"  表示 或者 如： “2015/2017”表示2015 或者 2017</para>
224         /// </summary>        
225         /// <returns></returns>
226         static bool VerifyConfigTimeStr(DateTime date, string timeStr)
227         {
228             List<string> strs = new List<string>();
229             string[] timeStrs = timeStr.Split(new char[] { ']' });
230             for (int i = 0; i < timeStrs.Length - 1; i++)
231             {
232                 string time = timeStrs[i].Replace("[", "");
233                 strs.Add(time);
234             }
235             if (VerifyDate(date.Year, strs[0]))
236             {
237                 if (VerifyDate(date.Month, strs[1]))
238                 {
239                     int week = (int)date.DayOfWeek;
240                     if (week == 0) { week = 7; }//星期天
241                     if (VerifyDate(week, strs[3]))
242                     {
243                         if (VerifyDate(date.Day, strs[2]))
244                         {
245                             if (VerifyTime(date, strs[4])) { return true; }
246                         }
247                     }
248                 }
249             }
250             return false;
251         }
252         #endregion
253 
254         #region 验证当前时间 年，月，日，星期，是否符合 static bool VerifyDate(int nowItem, string items)
255         /// <summary>
256         /// 验证当前时间 年，月，日，星期，是否符合
257         /// </summary>
258         /// <param name="nowItem">参数</param>
259         /// <param name="items">1-7;表示 1 到 7 , 1/7 表示 1 或者 7</param>
260         /// <returns></returns>
261         static bool VerifyDate(int nowItem, string items)
262         {
263             string nowItemStr = nowItem.ToString();
264             if ("*".Equals(items) || nowItemStr.Equals(items)) { return true; }
265             else if (items.IndexOf("-") > 0)
266             {//区间划分
267                 string[] itemSplit = items.Split('-');
268                 int item1 = 9999;
269                 int.TryParse(itemSplit[0], out item1);
270                 int item2 = 9999;
271                 int.TryParse(itemSplit[1], out item2);
272 
273                 if (item1 <= nowItem && nowItem <= item2) { return true; }
274             }
275             else if (items.IndexOf("/") > 0)
276             {//或划分
277                 string[] weeksSplit = items.Split('/');
278                 foreach (var item in weeksSplit)
279                 {
280                     if (nowItemStr.Equals(item)) { return true; }
281                 }
282             }
283             return false;
284         }
285         #endregion
286 
287         #region 验证当期时间格式 static bool VerifyTime(DateTime date, string itemTime)
288         /// <summary>
289         /// 验证当期时间格式
290         /// </summary>
291         /// <param name="date"></param>
292         /// <param name="itemTime"></param>
293         /// <returns></returns>
294         static bool VerifyTime(DateTime date, string itemTime)
295         {
296             bool ret = false;
297             if (!"*".Equals(itemTime))
298             {
299                 var items = Regex.Split(itemTime, @"/");
300                 foreach (var item in items)
301                 {
302                     string[] itemTimes = item.Split('-');
303                     var hhmm = Regex.Split(itemTimes[0], @":|：");
304                     int hh = 24;
305                     int.TryParse(hhmm[0], out hh);
306                     int mm = 60;
307                     int.TryParse(hhmm[1], out mm);
308                     if (date.Hour > hh || (date.Hour == hh && date.Minute >= mm))
309                     {
310                         if (itemTimes.Length > 1)
311                         {
312                             var hhmm1 = Regex.Split(itemTimes[1], @":|：");
313                             int hh1 = 24;
314                             int.TryParse(hhmm1[0], out hh1);
315                             int mm1 = 60;
316                             int.TryParse(hhmm1[1], out mm1);
317                             if (date.Hour < hh1 || (date.Hour == hh1 && date.Minute < mm1)) { ret = true; }
318                             else { ret = false; }
319                         }
320                         else { ret = true; }
321                     }
322                     else { ret = false; }
323                     if (ret)
324                     {
325                         break;
326                     }
327                 }
328             }
329             else { ret = true; }
330             return ret;
331         }
332         #endregion
333 
334         #region 获取配置的年月日星期等信息 static List<int> GetConfigDate(DateTime date, int p1, string p3)
335         /// <summary>
336         /// 获取配置的年月日星期等信息
337         /// </summary>
338         /// <param name="date"></param>
339         /// <param name="p1"></param>
340         /// <param name="p3"></param>
341         /// <returns></returns>
342         static List<int> GetConfigDate(DateTime date, int p1, string p3)
343         {
344             List<int> rets = new List<int>();
345             string p1Str = p1.ToString();
346             if ("*".Equals(p3) || p1Str.Equals(p3))
347             {
348                 rets.Add(p1);
349                 rets.Add(p1 + 1);
350             }
351             else if (p3.IndexOf("-") > 0)
352             {
353                 string[] weekSplit = p3.Split('-');
354                 int week1 = 9999;
355                 int.TryParse(weekSplit[0], out week1);
356 
357                 int week2 = 9999;
358                 int.TryParse(weekSplit[1], out week2);
359                 for (int i = week1; i < week2 + 1; i++)
360                 {
361                     rets.Add(i);
362                 }
363             }
364             else if (p3.IndexOf("/") > 0)
365             {
366                 string[] weeksSplit = p3.Split('/');
367                 foreach (var item in weeksSplit)
368                 {
369                     int temp = 0;
370                     if (int.TryParse(item, out temp))
371                     {
372                         rets.Add(temp);
373                     }
374                 }
375             }
376             else
377             {
378                 int temp = 0;
379                 if (int.TryParse(p3, out temp))
380                 {
381                     rets.Add(temp);
382                 }
383             }
384             return rets;
385         }
386         #endregion
387 
388         #region 获取配置的时间字符串 static List<string> GetConfigTimeStr(string itemTime)
389         /// <summary>
390         /// 获取配置的时间字符串 
391         /// </summary>
392         /// <param name="itemTime">必须类似的格式 单条 00:00-23:59  多条00:00-23:59/00:00-23:59</param>
393         /// <returns></returns>
394         static List<string> GetConfigTimeStr(string itemTime)
395         {
396             List<string> retObjs = new List<string>();
397             // 00:00-23:59
398             if (!"*".Equals(itemTime))
399             {
400                 var items = Regex.Split(itemTime, @"/");
401                 foreach (var item in items)
402                 {
403                     string[] itemTimes = item.Split('-');
404                     retObjs.Add(itemTimes[0]);
405                 }
406             }
407             else
408             {
409                 retObjs.Add("00:00");
410             }
411             return retObjs;
412         }
413         #endregion
414     }
415 }

View Code

好了谢谢大家的收看。。。我搬砖去了。。。

忘了告诉大家，"-"表示间隔，"/"表示包含的意思支持多个时间配置器哦;

[2015][7][20-31][*][10:00-11:59/14:00-16:59];[2015][8][1-5][*][10:00-11:59/14:00-16:59]

这样配置表示2015年的7月20号到8月5号的每天两档活动~！

本想翻译java的，，，结果我太懒了。。。。

1楼kiler: 你大可参考下corn表达式的定义，不用自己发明一个格式

您的程序支持复杂的时间调度嘛

相关推荐