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

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

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

配置多种多样。比如，没做星期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点为配置开启时间

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

        #region 验证当前时间 年，月，日，星期，是否符合 static bool VerifyDate(int nowItem, string items)
        /// <summary>
        /// 验证当前时间 年，月，日，星期，是否符合
        /// </summary>
        /// <param name="items">1-7;表示 1 到 7 , 1/7 表示 1 或者 7</param>
        /// <returns></returns>
        static bool VerifyDate(int nowItem, string items)
        {
            string nowItemStr = nowItem.ToString();
            if ("*".Equals(items) || nowItemStr.Equals(items)) { return true; }
            else if (items.IndexOf("-") > 0)
            {//区间划分
                string[] itemSplit = items.Split('-');
                int item1 = 9999;
                int.TryParse(itemSplit[0], out item1);
                int item2 = 9999;
                int.TryParse(itemSplit[1], out item2);

                if (item1 <= nowItem && nowItem <= item2) { return true; }
            }
            else if (items.IndexOf("/") > 0)
            {//或划分
                string[] weeksSplit = items.Split('/');
                foreach (var item in weeksSplit)
                {
                    if (nowItemStr.Equals(item)) { return true; }
                }
            }
            return false;
        }
        #endregion

        #region 验证当期时间格式 static bool VerifyTime(DateTime date, string itemTime)
        /// <summary>
        /// 验证当期时间格式
        /// </summary>
        /// <param name="date"></param>
        /// <param name="itemTime"></param>
        /// <returns></returns>
        static bool VerifyTime(DateTime date, string itemTime)
        {
            bool ret = false;
            if (!"*".Equals(itemTime))
            {
                var items = Regex.Split(itemTime, @"/");
                foreach (var item in items)
                {
                    string[] itemTimes = item.Split('-');
                    var hhmm = Regex.Split(itemTimes[0], @":|：");
                    int hh = 24;
                    int.TryParse(hhmm[0], out hh);
                    int mm = 60;
                    int.TryParse(hhmm[1], out mm);
                    if (date.Hour > hh || (date.Hour == hh && date.Minute >= mm))
                    {
                        if (itemTimes.Length > 1)
                        {
                            var hhmm1 = Regex.Split(itemTimes[1], @":|：");
                            int hh1 = 24;
                            int.TryParse(hhmm1[0], out hh1);
                            int mm1 = 60;
                            int.TryParse(hhmm1[1], out mm1);
                            if (date.Hour < hh1 || (date.Hour == hh1 && date.Minute < mm1)) { ret = true; }
                            else { ret = false; }
                        }
                        else { ret = true; }
                    }
                    else { ret = false; }
                    if (ret)
                    {
                        break;
                    }
                }
            }
            else { ret = true; }
            return ret;
        }
        #endregion

看看结果

这样挺万能的吧？

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

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

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

卧槽。。

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

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

        #region 获取配置的年月日星期等信息 static List<int> GetConfigDate(DateTime date, int p1, string p3)
        /// <summary>
        /// 获取配置的年月日星期等信息
        /// </summary>
        /// <param name="date"></param>
        /// <param name="p1"></param>
        /// <param name="p3"></param>
        /// <returns></returns>
        static List<int> GetConfigDate(DateTime date, int p1, string p3)
        {
            List<int> rets = new List<int>();
            string p1Str = p1.ToString();
            if ("*".Equals(p3) || p1Str.Equals(p3))
            {
                rets.Add(p1);
                rets.Add(p1 + 1);
            }
            else if (p3.IndexOf("-") > 0)
            {
                string[] weekSplit = p3.Split('-');
                int week1 = 9999;
                int.TryParse(weekSplit[0], out week1);

                int week2 = 9999;
                int.TryParse(weekSplit[1], out week2);
                for (int i = week1; i < week2 + 1; i++)
                {
                    rets.Add(i);
                }
            }
            else if (p3.IndexOf("/") > 0)
            {
                string[] weeksSplit = p3.Split('/');
                foreach (var item in weeksSplit)
                {
                    int temp = 0;
                    if (int.TryParse(item, out temp))
                    {
                        rets.Add(temp);
                    }
                }
            }
            else
            {
                int temp = 0;
                if (int.TryParse(p3, out temp))
                {
                    rets.Add(temp);
                }
            }
            return rets;
        }
        #endregion

        #region 获取配置的时间字符串 static List<string> GetConfigTimeStr(string itemTime)
        /// <summary>
        /// 获取配置的时间字符串 
        /// </summary>
        /// <param name="itemTime">必须类似的格式 单条 00:00-23:59  多条00:00-23:59/00:00-23:59</param>
        /// <returns></returns>
        static List<string> GetConfigTimeStr(string itemTime)
        {
            List<string> retObjs = new List<string>();
            // 00:00-23:59
            if (!"*".Equals(itemTime))
            {
                var items = Regex.Split(itemTime, @"/");
                foreach (var item in items)
                {
                    string[] itemTimes = item.Split('-');
                    retObjs.Add(itemTimes[0]);
                }
            }
            else
            {
                retObjs.Add("00:00");
            }
            return retObjs;
        }
        #endregion

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

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

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

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

        #region 处理星期包含的日期 日  static void ActionWeekDay(int weekmin, int weekmax, ref List<int> days, ref List<int> months, ref List<int> years)
        /// <summary>
        /// 处理星期包含的日期 日
        /// </summary>
        /// <param name="weekmin"></param>
        /// <param name="weekmax"></param>
        /// <param name="days"></param>
        /// <param name="months"></param>
        /// <param name="years"></param>
        static void ActionWeekDay(int weekmin, int weekmax, ref List<int> days, ref List<int> months, ref List<int> years)
        {
            DateTime nowWeekDate = DateTime.Now;
            List<int> tempDays, tempMonths, tempYears;
            tempYears = years.ToList();
            tempMonths = months.ToList();
            tempDays = days.ToList();
            foreach (var itemYear in tempYears)
            {
                foreach (var itemMonth in tempMonths)
                {
                    int itemDay = 1;
                    if (nowWeekDate.Month == itemMonth)
                    {
                        itemDay = nowWeekDate.Day;
                    }
                    DateTime date = new DateTime(itemYear, itemMonth, itemDay);
                    for (int i = 0; i < 7; i++)
                    {
                        int week = (int)date.DayOfWeek;
                        if (week == 0)
                        {
                            week = 7;
                        }
                        if (weekmin <= week && week <= weekmax)
                        {
                            if (!days.Contains(date.Day))
                            {
                                days.Add(date.Day);
                            }
                            if (!months.Contains(date.Month))
                            {
                                months.Add(date.Month);
                            }
                            if (!years.Contains(date.Year))
                            {
                                years.Add(date.Year);
                            }
                        }
                        date = date.AddDays(1);
                    }
                }
            }
        }
        #endregion

验证器

   #region 验证时间:[*][*][20/22][*][10:00-11:59/16:00-17:59] static public long VerifyDateTime(string timeStr)
        /// <summary>
        /// 验证时间:[*][*][20/22][*][10:00-11:59/16:00-17:59]
        /// <para>第一个是年，，第二个是月，第三个是日期，第四个是星期，第五个是时间，</para>
        /// <para>每一个参数，"-" 表示 到 如：“2015-2017”表示 2015 到 2017, "/"  表示 或者 如： “2015/2017”表示2015 或者 2017</para>
        /// <para>返回值 -1 表示永久过期，0 表示在时间规则内，大于 0 表示倒计时</para>
        /// </summary> 
        static public long VerifyDateTime(string timeStr)
        {
            var items = Regex.Split(timeStr, @";|；");
            items.Reverse();
            long ret = -1;
            DateTime date = DateTime.Now;
            foreach (var item in items)
            {
                //验证时间匹配
                if (VerifyConfigTimeStr(date, item))
                {
                    ret = 0;
                    goto Lab_Exit;
                }
                //未通过时间匹配，检查返回剩余时间
                List<string> strs = new List<string>();
                string[] timeStrs = item.Split(new char[] { ']' });
                for (int i = 0; i < timeStrs.Length - 1; i++)
                {
                    string time = timeStrs[i].Replace("[", "");
                    strs.Add(time);
                }

                string times = strs[4];
                string weeks = strs[3];
                string days = strs[2];
                string months = strs[1];
                string years = strs[0];

                int hour = 0, minute = 0, second = 0;
                var tempYears = GetConfigDate(date, date.Year, years);
                var tempMonths = GetConfigDate(date, date.Month, months);
                var tempDays = GetConfigDate(date, date.Day, days);
                //由于星期比较特殊所以获取与星期相关的日期的时候有点诡异。
                if (!"*".Equals(weeks))
                {
                    if (weeks.IndexOf("-") > 0)
                    {
                        //星期的间隔模式
                        string[] weekSplit = weeks.Split('-');
                        int weekmin = 9999;
                        int.TryParse(weekSplit[0], out weekmin);
                        int weekmax = 9999;
                        int.TryParse(weekSplit[1], out weekmax);
                        ActionWeekDay(weekmin, weekmax, ref tempDays, ref tempMonths, ref tempYears);
                    }
                    else if (weeks.IndexOf("/") > 0)
                    {
                        //星期的或模式
                        string[] weeksSplit = weeks.Split('/');
                        int tempWeek;
                        if (int.TryParse(weeksSplit[0], out tempWeek))
                        {
                            if (0 <= tempWeek && tempWeek <= 7)
                            {
                                ActionWeekDay(tempWeek, tempWeek, ref tempDays, ref tempMonths, ref tempYears);
                            }
                        }
                    }
                    else
                    {
                        //特定星期的模式
                        int tempweek = 0;
                        if (int.TryParse(weeks, out tempweek))
                        {
                            ActionWeekDay(tempweek, tempweek, ref tempDays, ref tempMonths, ref tempYears);
                        }
                    }
                }
                else
                {
                    //未指定星期的模式
                    ActionWeekDay(1, 7, ref tempDays, ref tempMonths, ref tempYears);
                }

                var tempHHMMs = GetConfigTimeStr(times);

                //进行简单的排序
                tempYears.Sort();
                tempMonths.Sort();
                tempDays.Sort();
                tempHHMMs.Sort();

                //接下来这里是天坑，就是构造时间器比较，然后计算出倒计时
                for (int y = 0; y < tempYears.Count; y++)
                {
                    for (int m = 0; m < tempMonths.Count; m++)
                    {
                        for (int d = 0; d < tempDays.Count; d++)
                        {
                            for (int h = 0; h < tempHHMMs.Count; h++)
                            {
                                string[] hhmm = Regex.Split(tempHHMMs[h], ":|：");
                                if (int.TryParse(hhmm[0], out hour) && int.TryParse(hhmm[1], out minute))
                                {
                                    DateTime actionTime = new DateTime(tempYears[y], tempMonths[m], tempDays[d], hour, minute, second);
                                    if (actionTime > date)
                                    {
                                        if (VerifyConfigTimeStr(actionTime, item))
                                        {
                                            Console.WriteLine(actionTime.ToString("yyyy-MM-dd HH:mm:ss"));
                                            TimeSpan ts = (actionTime - date);
                                            ret = ts.Days * 24 * 60 * 60 + ts.Hours * 60 * 60 + ts.Minutes * 60 + ts.Seconds;
                                            ret *= 1000;
                                            ret += ts.Milliseconds;
                                            goto Lab_Exit;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        Lab_Exit:
            return ret;
        }
        #endregion

验证活动配置时间

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

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

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

全部完整代码。。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

/**
 * 
 * @author 失足程序员
 * @Blog http://www.cnblogs.com/ty408/
 * @mail 492794628@qq.com
 * @phone 13882122019
 * 
 */
namespace Sz
{
    /// <summary>
    /// 时间验证器
    /// </summary>
    public static class TimeUtil
    {

        //static void Main(string[] args)
        //{
        //    Console.WriteLine("验证当期时间是否满足活动开放时间：[*][*][20/22][*][10:00-11:59/16:00-17:59]");
        //    System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
        //    watch.Restart();
        //    for (int i = 0; i < 5; i++)
        //    {
        //        long ticks = TimeUtil.VerifyDateTime("[2014/2016][9][*][*][10:00-11:59/16:00-22:59]");
        //        Console.WriteLine(ticks + " 倒计时：" + (ticks / 1000) + "秒");
        //    }
        //    watch.Stop();
        //    Console.WriteLine(watch.ElapsedMilliseconds);
        //    Console.ReadLine();
        //}


        /// <summary>
        /// 验证时间:[*][*][20/22][*][10:00-11:59/16:00-17:59]
        /// <para>第一个是年，，第二个是月，第三个是日期，第四个是星期，第五个是时间，</para>
        /// <para>每一个参数，"-" 表示 到 如：“2015-2017”表示 2015 到 2017, "/"  表示 或者 如： “2015/2017”表示2015 或者 2017</para>
        /// <para>返回值 -1 表示永久过期，0 表示在时间规则内，大于 0 表示倒计时</para>
        /// </summary> 
        static public long VerifyDateTime(string timeStr)
        {
            var items = Regex.Split(timeStr, @";|；");
            items.Reverse();
            long ret = -1;
            DateTime date = DateTime.Now;
            foreach (var item in items)
            {
                //验证时间匹配
                if (VerifyConfigTimeStr(date, item))
                {
                    ret = 0;
                    goto Lab_Exit;
                }
                //未通过时间匹配，检查返回剩余时间
                List<string> strs = new List<string>();
                string[] timeStrs = item.Split(new char[] { ']' });
                for (int i = 0; i < timeStrs.Length - 1; i++)
                {
                    string time = timeStrs[i].Replace("[", "");
                    strs.Add(time);
                }

                string times = strs[4];
                string weeks = strs[3];
                string days = strs[2];
                string months = strs[1];
                string years = strs[0];

                int hour = 0, minute = 0, second = 0;
                var tempYears = GetConfigDate(date, date.Year, years);
                var tempMonths = GetConfigDate(date, date.Month, months);
                var tempDays = GetConfigDate(date, date.Day, days);
                //由于星期比较特殊所以获取与星期相关的日期的时候有点诡异。
                if (!"*".Equals(weeks))
                {
                    if (weeks.IndexOf("-") > 0)
                    {
                        //星期的间隔模式
                        string[] weekSplit = weeks.Split('-');
                        int weekmin = 9999;
                        int.TryParse(weekSplit[0], out weekmin);
                        int weekmax = 9999;
                        int.TryParse(weekSplit[1], out weekmax);
                        ActionWeekDay(weekmin, weekmax, ref tempDays, ref tempMonths, ref tempYears);
                    }
                    else if (weeks.IndexOf("/") > 0)
                    {
                        //星期的或模式
                        string[] weeksSplit = weeks.Split('/');
                        int tempWeek;
                        if (int.TryParse(weeksSplit[0], out tempWeek))
                        {
                            if (0 <= tempWeek && tempWeek <= 7)
                            {
                                ActionWeekDay(tempWeek, tempWeek, ref tempDays, ref tempMonths, ref tempYears);
                            }
                        }
                    }
                    else
                    {
                        //特定星期的模式
                        int tempweek = 0;
                        if (int.TryParse(weeks, out tempweek))
                        {
                            ActionWeekDay(tempweek, tempweek, ref tempDays, ref tempMonths, ref tempYears);
                        }
                    }
                }
                else
                {
                    //未指定星期的模式
                    ActionWeekDay(1, 7, ref tempDays, ref tempMonths, ref tempYears);
                }

                var tempHHMMs = GetConfigTimeStr(times);

                //进行简单的排序
                tempYears.Sort();
                tempMonths.Sort();
                tempDays.Sort();
                tempHHMMs.Sort();

                //接下来这里是天坑，就是构造时间器比较，然后计算出倒计时
                for (int y = 0; y < tempYears.Count; y++)
                {
                    for (int m = 0; m < tempMonths.Count; m++)
                    {
                        for (int d = 0; d < tempDays.Count; d++)
                        {
                            for (int h = 0; h < tempHHMMs.Count; h++)
                            {
                                string[] hhmm = Regex.Split(tempHHMMs[h], ":|：");
                                if (int.TryParse(hhmm[0], out hour) && int.TryParse(hhmm[1], out minute))
                                {
                                    DateTime actionTime = new DateTime(tempYears[y], tempMonths[m], tempDays[d], hour, minute, second);
                                    if (actionTime > date)
                                    {
                                        if (VerifyConfigTimeStr(actionTime, item))
                                        {
                                            Console.WriteLine(actionTime.ToString("yyyy-MM-dd HH:mm:ss"));
                                            TimeSpan ts = (actionTime - date);
                                            ret = ts.Days * 24 * 60 * 60 + ts.Hours * 60 * 60 + ts.Minutes * 60 + ts.Seconds;
                                            ret *= 1000;
                                            ret += ts.Milliseconds;
                                            goto Lab_Exit;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        Lab_Exit:
            return ret;
        }

        #region 处理星期包含的日期 日  static void ActionWeekDay(int weekmin, int weekmax, ref List<int> days, ref List<int> months, ref List<int> years)
        /// <summary>
        /// 处理星期包含的日期 日
        /// </summary>
        /// <param name="weekmin"></param>
        /// <param name="weekmax"></param>
        /// <param name="days"></param>
        /// <param name="months"></param>
        /// <param name="years"></param>
        static void ActionWeekDay(int weekmin, int weekmax, ref List<int> days, ref List<int> months, ref List<int> years)
        {
            DateTime nowWeekDate = DateTime.Now;
            List<int> tempDays, tempMonths, tempYears;
            tempYears = years.ToList();
            tempMonths = months.ToList();
            tempDays = days.ToList();
            foreach (var itemYear in tempYears)
            {
                foreach (var itemMonth in tempMonths)
                {
                    int itemDay = 1;
                    if (nowWeekDate.Month == itemMonth)
                    {
                        itemDay = nowWeekDate.Day;
                    }
                    DateTime date = new DateTime(itemYear, itemMonth, itemDay);
                    for (int i = 0; i < 7; i++)
                    {
                        int week = (int)date.DayOfWeek;
                        if (week == 0)
                        {
                            week = 7;
                        }
                        if (weekmin <= week && week <= weekmax)
                        {
                            if (!days.Contains(date.Day))
                            {
                                days.Add(date.Day);
                            }
                            if (!months.Contains(date.Month))
                            {
                                months.Add(date.Month);
                            }
                            if (!years.Contains(date.Year))
                            {
                                years.Add(date.Year);
                            }
                        }
                        date = date.AddDays(1);
                    }
                }
            }
        }
        #endregion

        #region 验证时间:[*][*][20/22][*][10:00-11:59/16:00-17:59] static bool VerifyConfigTimeStr(DateTime date, string timeStr)
        /// <summary>
        /// 验证时间:[*][*][20/22][*][10:00-11:59/16:00-17:59]
        /// <para>第一个是年，，第二个是月，第三个是日期，第四个是星期，第五个是时间，</para>
        /// <para>每一个参数，"-" 表示 到 如：“2015-2017”表示 2015 到 2017, "/"  表示 或者 如： “2015/2017”表示2015 或者 2017</para>
        /// </summary>        
        /// <returns></returns>
        static bool VerifyConfigTimeStr(DateTime date, string timeStr)
        {
            List<string> strs = new List<string>();
            string[] timeStrs = timeStr.Split(new char[] { ']' });
            for (int i = 0; i < timeStrs.Length - 1; i++)
            {
                string time = timeStrs[i].Replace("[", "");
                strs.Add(time);
            }
            if (VerifyDate(date.Year, strs[0]))
            {
                if (VerifyDate(date.Month, strs[1]))
                {
                    int week = (int)date.DayOfWeek;
                    if (week == 0) { week = 7; }//星期天
                    if (VerifyDate(week, strs[3]))
                    {
                        if (VerifyDate(date.Day, strs[2]))
                        {
                            if (VerifyTime(date, strs[4])) { return true; }
                        }
                    }
                }
            }
            return false;
        }
        #endregion

        #region 验证当前时间 年，月，日，星期，是否符合 static bool VerifyDate(int nowItem, string items)
        /// <summary>
        /// 验证当前时间 年，月，日，星期，是否符合
        /// </summary>
        /// <param name="nowItem">参数</param>
        /// <param name="items">1-7;表示 1 到 7 , 1/7 表示 1 或者 7</param>
        /// <returns></returns>
        static bool VerifyDate(int nowItem, string items)
        {
            string nowItemStr = nowItem.ToString();
            if ("*".Equals(items) || nowItemStr.Equals(items)) { return true; }
            else if (items.IndexOf("-") > 0)
            {//区间划分
                string[] itemSplit = items.Split('-');
                int item1 = 9999;
                int.TryParse(itemSplit[0], out item1);
                int item2 = 9999;
                int.TryParse(itemSplit[1], out item2);

                if (item1 <= nowItem && nowItem <= item2) { return true; }
            }
            else if (items.IndexOf("/") > 0)
            {//或划分
                string[] weeksSplit = items.Split('/');
                foreach (var item in weeksSplit)
                {
                    if (nowItemStr.Equals(item)) { return true; }
                }
            }
            return false;
        }
        #endregion

        #region 验证当期时间格式 static bool VerifyTime(DateTime date, string itemTime)
        /// <summary>
        /// 验证当期时间格式
        /// </summary>
        /// <param name="date"></param>
        /// <param name="itemTime"></param>
        /// <returns></returns>
        static bool VerifyTime(DateTime date, string itemTime)
        {
            bool ret = false;
            if (!"*".Equals(itemTime))
            {
                var items = Regex.Split(itemTime, @"/");
                foreach (var item in items)
                {
                    string[] itemTimes = item.Split('-');
                    var hhmm = Regex.Split(itemTimes[0], @":|：");
                    int hh = 24;
                    int.TryParse(hhmm[0], out hh);
                    int mm = 60;
                    int.TryParse(hhmm[1], out mm);
                    if (date.Hour > hh || (date.Hour == hh && date.Minute >= mm))
                    {
                        if (itemTimes.Length > 1)
                        {
                            var hhmm1 = Regex.Split(itemTimes[1], @":|：");
                            int hh1 = 24;
                            int.TryParse(hhmm1[0], out hh1);
                            int mm1 = 60;
                            int.TryParse(hhmm1[1], out mm1);
                            if (date.Hour < hh1 || (date.Hour == hh1 && date.Minute < mm1)) { ret = true; }
                            else { ret = false; }
                        }
                        else { ret = true; }
                    }
                    else { ret = false; }
                    if (ret)
                    {
                        break;
                    }
                }
            }
            else { ret = true; }
            return ret;
        }
        #endregion

        #region 获取配置的年月日星期等信息 static List<int> GetConfigDate(DateTime date, int p1, string p3)
        /// <summary>
        /// 获取配置的年月日星期等信息
        /// </summary>
        /// <param name="date"></param>
        /// <param name="p1"></param>
        /// <param name="p3"></param>
        /// <returns></returns>
        static List<int> GetConfigDate(DateTime date, int p1, string p3)
        {
            List<int> rets = new List<int>();
            string p1Str = p1.ToString();
            if ("*".Equals(p3) || p1Str.Equals(p3))
            {
                rets.Add(p1);
                rets.Add(p1 + 1);
            }
            else if (p3.IndexOf("-") > 0)
            {
                string[] weekSplit = p3.Split('-');
                int week1 = 9999;
                int.TryParse(weekSplit[0], out week1);

                int week2 = 9999;
                int.TryParse(weekSplit[1], out week2);
                for (int i = week1; i < week2 + 1; i++)
                {
                    rets.Add(i);
                }
            }
            else if (p3.IndexOf("/") > 0)
            {
                string[] weeksSplit = p3.Split('/');
                foreach (var item in weeksSplit)
                {
                    int temp = 0;
                    if (int.TryParse(item, out temp))
                    {
                        rets.Add(temp);
                    }
                }
            }
            else
            {
                int temp = 0;
                if (int.TryParse(p3, out temp))
                {
                    rets.Add(temp);
                }
            }
            return rets;
        }
        #endregion

        #region 获取配置的时间字符串 static List<string> GetConfigTimeStr(string itemTime)
        /// <summary>
        /// 获取配置的时间字符串 
        /// </summary>
        /// <param name="itemTime">必须类似的格式 单条 00:00-23:59  多条00:00-23:59/00:00-23:59</param>
        /// <returns></returns>
        static List<string> GetConfigTimeStr(string itemTime)
        {
            List<string> retObjs = new List<string>();
            // 00:00-23:59
            if (!"*".Equals(itemTime))
            {
                var items = Regex.Split(itemTime, @"/");
                foreach (var item in items)
                {
                    string[] itemTimes = item.Split('-');
                    retObjs.Add(itemTimes[0]);
                }
            }
            else
            {
                retObjs.Add("00:00");
            }
            return retObjs;
        }
        #endregion
    }
}

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

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

[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的，，，结果我太懒了。。。。