static public bool TryParse(string s, ExpressionSectionType type, out IgnoreExpressionSection result)
        {
            result = default(IgnoreExpressionSection);
            if (string.IsNullOrEmpty(s)) return false;
            if (!string.Equals("?", s, StringComparison.OrdinalIgnoreCase)) return false;

            switch (type)
            {
                case ExpressionSectionType.DayOfMonth:
                    result = _dayOfMonthInstance;
                    break;
                case ExpressionSectionType.DayOfWeek:
                    result = _dayOfWeekInstance;
                    break;

                case ExpressionSectionType.Hour:
                    result = _hourInstance;
                    break;

                case ExpressionSectionType.Minute:
                    result = _minuteInstance;
                    break;

                case ExpressionSectionType.Month:
                    result = _monthInstance;
                    break;

                default:
                    throw new InvalidOperationException(string.Format("Unexpected {0} {1}",
                                                                      typeof(ExpressionSectionType).Name,
                                                                      type));
            }

            return true;
        }
        static public bool TryParse(string s, ExpressionSectionType type, out IgnoreExpressionSection result)
        {
            result = default(IgnoreExpressionSection);
            if (string.IsNullOrEmpty(s))
            {
                return(false);
            }
            if (!string.Equals("?", s, StringComparison.OrdinalIgnoreCase))
            {
                return(false);
            }

            switch (type)
            {
            case ExpressionSectionType.DayOfMonth:
                result = _dayOfMonthInstance;
                break;

            case ExpressionSectionType.DayOfWeek:
                result = _dayOfWeekInstance;
                break;

            case ExpressionSectionType.Hour:
                result = _hourInstance;
                break;

            case ExpressionSectionType.Minute:
                result = _minuteInstance;
                break;

            case ExpressionSectionType.Month:
                result = _monthInstance;
                break;

            default:
                throw new InvalidOperationException(string.Format("Unexpected {0} {1}",
                                                                  typeof(ExpressionSectionType).Name,
                                                                  type));
            }

            return(true);
        }
        static public bool TryParse(string s, ExpressionSectionType type, out ExpressionSectionBase result)
        {
            result = default(ExpressionSectionBase);

            if (string.IsNullOrEmpty(s))
            {
                return(false);
            }

            EveryOccurenceExpressionSection every;

            if (EveryOccurenceExpressionSection.TryParse(s, type, out every))
            {
                result = every;
                return(true);
            }
            IgnoreExpressionSection ignore;

            if (IgnoreExpressionSection.TryParse(s, type, out ignore))
            {
                if (type != ExpressionSectionType.DayOfMonth && type != ExpressionSectionType.DayOfWeek)
                {
                    return(false);
                }
                result = ignore;
                return(true);
            }

            RangeExpressionSection range;

            if (RangeExpressionSection.TryParse(s, type, out range))
            {
                result = range;
                return(true);
            }

            RepeatingExpressionSection repeating;

            if (RepeatingExpressionSection.TryParse(s, type, out repeating))
            {
                result = repeating;
                return(true);
            }

            ListExpressionSection list;

            if (ListExpressionSection.TryParse(s, type, out list))
            {
                result = list;
                return(true);
            }

            switch (type)
            {
            case ExpressionSectionType.Month:
                MonthExpressionSection month;
                if (!MonthExpressionSection.TryParse(s, out month))
                {
                    return(false);
                }
                result = month;
                return(true);

            case ExpressionSectionType.DayOfWeek:
                DayOfWeekExpressionSection dayOfWeek;
                if (DayOfWeekExpressionSection.TryParse(s, out dayOfWeek))
                {
                    result = dayOfWeek;
                    return(true);
                }
                SpecifiedWeekAndWeekDayExpressionSection specifiedDayAndWeekDay;
                if (SpecifiedWeekAndWeekDayExpressionSection.TryParse(s, out specifiedDayAndWeekDay))
                {
                    result = specifiedDayAndWeekDay;
                    return(true);
                }
                goto default;

            case ExpressionSectionType.DayOfMonth:
                LastDayOfMonthExpressionSection lastDayOfMonth;
                if (LastDayOfMonthExpressionSection.TryParse(s, out lastDayOfMonth))
                {
                    result = lastDayOfMonth;
                    return(true);
                }
                NearestWeekdayExpressionSection nearestWeekDay;
                if (NearestWeekdayExpressionSection.TryParse(s, out nearestWeekDay))
                {
                    result = nearestWeekDay;
                    return(true);
                }
                LastWeekDayOfMonthExpressionSection lastWeekDay;
                if (LastWeekDayOfMonthExpressionSection.TryParse(s, out lastWeekDay))
                {
                    result = lastWeekDay;
                    return(true);
                }
                goto default;

            default:
                SimpleExpressionSection simple;
                if (!SimpleExpressionSection.TryParse(s, type, out simple))
                {
                    return(false);
                }
                result = simple;
                return(true);
            }
        }