示例#1
0
        /// <summary>
        /// Dates the difference.
        /// </summary>
        /// <param name="startDate">The start date.</param>
        /// <param name="endDate">The end date.</param>
        /// <param name="part">The part.</param>
        /// <returns></returns>
        public static long DateDiff(this DateTime startDate, DateTime endDate, DateParts part)
        {
            var datePart = string.Empty;

            switch (part)
            {
            case DateParts.Year: datePart = "yy"; break;

            case DateParts.Quarter: datePart = "q"; break;

            case DateParts.Month: datePart = "m"; break;

            case DateParts.Day: datePart = "d"; break;

            case DateParts.Week: datePart = "w"; break;

            case DateParts.Hour: datePart = "h"; break;

            case DateParts.Minute: datePart = "n"; break;

            case DateParts.Second: datePart = "s"; break;

            case DateParts.Millisecond: datePart = "ms"; break;
            }

            return(startDate.DateDiff(endDate, datePart));
        }
示例#2
0
        public static DateTime?DateAdd(DateParts part, DateTime?date, double?number)
        {
            if (number == null || date == null)
            {
                return(null);
            }

            switch (part)
            {
            case DateParts.Year: return(date.Value.AddYears(Converter.Convert <double, int>(number.Value)));

            case DateParts.Quarter: return(date.Value.AddMonths(Converter.Convert <double, int>(number.Value) * 3));

            case DateParts.Month: return(date.Value.AddMonths(Converter.Convert <double, int>(number.Value)));

            case DateParts.DayOfYear: return(date.Value.AddDays(number.Value));

            case DateParts.Day: return(date.Value.AddDays(number.Value));

            case DateParts.Week: return(date.Value.AddDays(number.Value * 7));

            case DateParts.DayOfWeek: return(date.Value.AddDays(number.Value));

            case DateParts.Hour: return(date.Value.AddHours(number.Value));

            case DateParts.Minute: return(date.Value.AddMinutes(number.Value));

            case DateParts.Second: return(date.Value.AddSeconds(number.Value));

            case DateParts.Millisecond: return(date.Value.AddMilliseconds(number.Value));
                //By zxm
                //case DateParts.: return date.Value.AddMilliseconds
            }
            throw new NotSupportedException(Linq_DbFunctionDirectCall);
        }
示例#3
0
        public static int?DatePart(DateParts part, DateTime?date)
        {
            if (date == null)
            {
                return(null);
            }

            switch (part)
            {
            case DateParts.Year: return(date.Value.Year);

            case DateParts.Quarter: return((date.Value.Month - 1) / 3 + 1);

            case DateParts.Month: return(date.Value.Month);

            case DateParts.DayOfYear: return(date.Value.DayOfYear);

            case DateParts.Day: return(date.Value.Day);

            case DateParts.Week: return(CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(date.Value, CalendarWeekRule.FirstDay, DayOfWeek.Sunday));

            case DateParts.DayOfWeek: return((int)date.Value.DayOfWeek);

            case DateParts.Hour: return(date.Value.Hour);

            case DateParts.Minute: return(date.Value.Minute);

            case DateParts.Second: return(date.Value.Second);

            case DateParts.Millisecond: return(date.Value.Millisecond);
            }
            throw new NotSupportedException(Linq_DbFunctionDirectCall);
        }
示例#4
0
            public static string DatePartToStr(DateParts part)
            {
                string partStr;

                switch (part)
                {
                case Sql.DateParts.Year: partStr = "year";        break;

                case Sql.DateParts.Quarter: partStr = "quarter";     break;

                case Sql.DateParts.Month: partStr = "month";       break;

                case Sql.DateParts.DayOfYear: partStr = "dayofyear";   break;

                case Sql.DateParts.Day: partStr = "day";         break;

                case Sql.DateParts.Week: partStr = "week";        break;

                case Sql.DateParts.WeekDay: partStr = "weekday";     break;

                case Sql.DateParts.Hour: partStr = "hour";        break;

                case Sql.DateParts.Minute: partStr = "minute";      break;

                case Sql.DateParts.Second: partStr = "second";      break;

                case Sql.DateParts.Millisecond: partStr = "millisecond"; break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
                return(partStr);
            }
示例#5
0
        public static int?DateDiff(DateParts part, DateTime?startDate, DateTime?endDate)
        {
            if (startDate == null || endDate == null)
            {
                return(null);
            }

            switch (part)
            {
            case DateParts.Day:
                return((int)(endDate - startDate).Value.TotalDays);

            case DateParts.Hour:
                return((int)(endDate - startDate).Value.TotalHours);

            case DateParts.Minute:
                return((int)(endDate - startDate).Value.TotalMinutes);

            case DateParts.Second:
                return((int)(endDate - startDate).Value.TotalSeconds);

            case DateParts.Millisecond:
                return((int)(endDate - startDate).Value.TotalMilliseconds);
            }

            throw new InvalidOperationException();
        }
示例#6
0
文件: DateAdd.cs 项目: jgshort/SqlDom
 public DateAdd(DateParts datePart, Expression number, Expression date)
     : base(null)
 {
     DatePart = datePart;
     Number = number;
     Date = date;
 }
示例#7
0
        private Type partTypeToType(DateParts dateParts)
        {
            switch ((int)dateParts)
            {
            case (int)DateParts.dateTime:
                return(typeof(DateTime));

            case (int)DateParts.date:
                return(typeof(DateTime));

            case (int)DateParts.dateInt:
                return(typeof(int));

            case (int)DateParts.timeInt:
                return(typeof(int));

            case (int)DateParts.year:
            case (int)DateParts.month:
            case (int)DateParts.day:
            case (int)DateParts.hour:
            case (int)DateParts.minute:
            case (int)DateParts.second:
                return(typeof(short));
            }

            return(typeof(object));
        }
示例#8
0
文件: Sql.cs 项目: szp11/bltoolkit
        public static DateTime?DateAdd(DateParts part, double?number, DateTime?date)
        {
            if (number == null || date == null)
            {
                return(null);
            }

            switch (part)
            {
            case DateParts.Year: return(date.Value.AddYears((int)number));

            case DateParts.Quarter: return(date.Value.AddMonths((int)number * 3));

            case DateParts.Month: return(date.Value.AddMonths((int)number));

            case DateParts.DayOfYear: return(date.Value.AddDays(number.Value));

            case DateParts.Day: return(date.Value.AddDays(number.Value));

            case DateParts.Week: return(date.Value.AddDays(number.Value * 7));

            case DateParts.WeekDay: return(date.Value.AddDays(number.Value));

            case DateParts.Hour: return(date.Value.AddHours(number.Value));

            case DateParts.Minute: return(date.Value.AddMinutes(number.Value));

            case DateParts.Second: return(date.Value.AddSeconds(number.Value));

            case DateParts.Millisecond: return(date.Value.AddMilliseconds(number.Value));
            }

            throw new InvalidOperationException();
        }
示例#9
0
文件: Sql.cs 项目: szp11/bltoolkit
        public static int?DatePart(DateParts part, DateTime?date)
        {
            if (date == null)
            {
                return(null);
            }

            switch (part)
            {
            case DateParts.Year: return(date.Value.Year);

            case DateParts.Quarter: return((date.Value.Month - 1) / 3 + 1);

            case DateParts.Month: return(date.Value.Month);

            case DateParts.DayOfYear: return(date.Value.DayOfYear);

            case DateParts.Day: return(date.Value.Day);

            case DateParts.Week: return(CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(date.Value, CalendarWeekRule.FirstDay, DayOfWeek.Sunday));

            case DateParts.WeekDay: return(((int)date.Value.DayOfWeek + 1 + DateFirst + 6) % 7 + 1);

            case DateParts.Hour: return(date.Value.Hour);

            case DateParts.Minute: return(date.Value.Minute);

            case DateParts.Second: return(date.Value.Second);

            case DateParts.Millisecond: return(date.Value.Millisecond);
            }

            throw new InvalidOperationException();
        }
示例#10
0
        public static int?DateDiff(DateParts part, DateTime?startDate, DateTime?endDate)
        {
            if (startDate == null || endDate == null)
            {
                return(null);
            }

            return(DateDiff(part, startDate.Value, endDate.Value));
        }
        protected virtual void GetDateFormatValues(DateParts parts, Calendar calendar, out int twoDigitYear, out string monthName, out string monthNameShort, out string monthNameGenitive, out string monthNameShortGenitive, out string dayName, out string dayNameShort)
        {
            var yearString = parts.Year.ToString("00", System.Globalization.CultureInfo.InvariantCulture);

            twoDigitYear           = Int32.Parse(yearString.Substring(yearString.Length - 2));
            monthName              = parts.Month > 0 ? _dateTimeFormatProvider.MonthNames[parts.Month - 1] : null;
            monthNameShort         = parts.Month > 0 ? _dateTimeFormatProvider.MonthNamesShort[parts.Month - 1] : null;
            monthNameGenitive      = parts.Month > 0 ? _dateTimeFormatProvider.MonthNamesGenitive[parts.Month - 1] : null;
            monthNameShortGenitive = parts.Month > 0 ? _dateTimeFormatProvider.MonthNamesShortGenitive[parts.Month - 1] : null;
            dayName      = parts.Day > 0 ? _dateTimeFormatProvider.DayNames[(int)calendar.GetDayOfWeek(parts.ToDateTime(calendar))] : null;
            dayNameShort = parts.Day > 0 ? _dateTimeFormatProvider.DayNamesShort[(int)calendar.GetDayOfWeek(parts.ToDateTime(calendar))] : null;
        }
示例#12
0
        public virtual string FormatDate(DateParts parts, string format)
        {
            var useMonthNameGenitive = GetUseGenitiveMonthName(format);

            var replacements = GetDateFormatReplacements(useMonthNameGenitive);
            var formatString = ConvertToFormatString(format, replacements);
            var calendar     = CurrentCalendar;

            int    twoDigitYear;
            string monthName, monthNameShort, monthNameGenitive, monthNameShortGenitive, dayName, dayNameShort, eraName, eraNameShort;

            GetDateFormatValues(parts, calendar, out twoDigitYear, out monthName, out monthNameShort, out monthNameGenitive, out monthNameShortGenitive, out dayName, out dayNameShort, out eraName, out eraNameShort);

            return(String.Format(formatString, parts.Year, twoDigitYear, parts.Month, monthName, monthNameShort, monthNameGenitive, monthNameShortGenitive, parts.Day, dayName, dayNameShort, eraName, eraNameShort));
        }
示例#13
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="part"></param>
        /// <param name="startDate"></param>
        /// <param name="endDate"></param>
        /// <returns></returns>
        public static int DateDiff(DateParts part, DateTime startDate, DateTime endDate)
        {
            switch (part)
            {
            case DateParts.Day: return((endDate - startDate).Days);

            case DateParts.Hour: return((endDate - startDate).Hours);

            case DateParts.Minute: return((endDate - startDate).Minutes);

            case DateParts.Second: return((endDate - startDate).Seconds);

            case DateParts.Millisecond: return((endDate - startDate).Milliseconds);
            }
            throw new NotSupportedException(Linq_DbFunctionDirectCall);
        }
示例#14
0
        private DateTime setDateTimePatr(DateTime dt, DateParts dateParts, object val)
        {
            DateTime tmpDT;
            int      tmpInt;

            switch ((int)dateParts)
            {
            //case (int)DateParts.dateTime:
            //    return dt;
            case (int)DateParts.date:
                tmpDT = (DateTime)val;
                return(new DateTime(tmpDT.Year, tmpDT.Month, tmpDT.Day, dt.Hour, dt.Minute, dt.Second));

            case (int)DateParts.dateInt:
                tmpDT = ToolGeneral.intDate2Date((int)val);
                return(new DateTime(tmpDT.Year, tmpDT.Month, tmpDT.Day, dt.Hour, dt.Minute, dt.Second));

            case (int)DateParts.timeInt:
                tmpDT = ToolGeneral.intTime2Time((int)val);
                return(new DateTime(dt.Year, dt.Month, dt.Day, tmpDT.Hour, tmpDT.Minute, tmpDT.Second));

            case (int)DateParts.year:
                tmpInt = ToolType.intoRange(Convert.ToInt32(val), 1, 9999);
                return(new DateTime(tmpInt, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second));

            case (int)DateParts.month:
                tmpInt = ToolType.intoRange(Convert.ToInt32(val), 1, 12);
                return(new DateTime(dt.Year, tmpInt, dt.Day, dt.Hour, dt.Minute, dt.Second));

            case (int)DateParts.day:
                tmpInt = ToolType.intoRange(Convert.ToInt32(val), 1, 31);
                return(new DateTime(dt.Year, dt.Month, tmpInt, dt.Hour, dt.Minute, dt.Second));

            case (int)DateParts.hour:
                tmpInt = ToolType.intoRange(Convert.ToInt32(val), 0, 23);
                return(new DateTime(dt.Year, dt.Month, dt.Day, tmpInt, dt.Minute, dt.Second));

            case (int)DateParts.minute:
                tmpInt = ToolType.intoRange(Convert.ToInt32(val), 0, 59);
                return(new DateTime(dt.Year, dt.Month, dt.Day, dt.Hour, tmpInt, dt.Second));

            case (int)DateParts.second:
                tmpInt = ToolType.intoRange(Convert.ToInt32(val), 0, 59);
                return(new DateTime(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, tmpInt));
            }
            return(dt);
        }
示例#15
0
 public static string DatePartToStr(DateParts part)
 {
     return(part switch
     {
         Sql.DateParts.Year => "year",
         Sql.DateParts.Quarter => "quarter",
         Sql.DateParts.Month => "month",
         Sql.DateParts.DayOfYear => "dayofyear",
         Sql.DateParts.Day => "day",
         Sql.DateParts.Week => "week",
         Sql.DateParts.WeekDay => "weekday",
         Sql.DateParts.Hour => "hour",
         Sql.DateParts.Minute => "minute",
         Sql.DateParts.Second => "second",
         Sql.DateParts.Millisecond => "millisecond",
         _ => throw new ArgumentOutOfRangeException(),
     });
示例#16
0
 public static string DatePartToStr(DateParts part)
 {
     return(part switch
     {
         DateParts.Year => "year",
         DateParts.Quarter => "quarter",
         DateParts.Month => "month",
         DateParts.DayOfYear => "dayofyear",
         DateParts.Day => "day",
         DateParts.Week => "week",
         DateParts.WeekDay => "weekday",
         DateParts.Hour => "hour",
         DateParts.Minute => "minute",
         DateParts.Second => "second",
         DateParts.Millisecond => "millisecond",
         _ => throw new InvalidOperationException($"Unexpected datepart: {part}")
     });
示例#17
0
        public static int?DatePart([SqlQueryDependent] DateParts part, [ExprParameter] DateOnly?date)
        {
            if (date == null)
            {
                return(null);
            }

            return(part switch
            {
                DateParts.Year => date.Value.Year,
                DateParts.Quarter => (date.Value.Month - 1) / 3 + 1,
                DateParts.Month => date.Value.Month,
                DateParts.DayOfYear => date.Value.DayOfYear,
                DateParts.Day => date.Value.Day,
                DateParts.Week => CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(date.Value.ToDateTime(TimeOnly.MinValue), CalendarWeekRule.FirstDay, DayOfWeek.Sunday),
                DateParts.WeekDay => ((int)date.Value.DayOfWeek + 1 + DateFirst + 6) % 7 + 1,
                _ => throw new InvalidOperationException(),
            });
示例#18
0
        /// <summary>
        /// Converts a QueryOperator to a string
        /// </summary>
        public static string ToQuery(this DateParts dp)
        {
            switch (dp)
            {
            case DateParts.Year:
                return("yy");

            case DateParts.Quarter:
                return("qq");

            case DateParts.Dayofyear:
                return("dy");

            case DateParts.Week:
                return("wk");

            case DateParts.IsoWeek:
                return("isoww");

            case DateParts.Month:
                return("mm");

            case DateParts.Day:
                return("dd");

            case DateParts.Weekday:
                return("dw");

            case DateParts.Hour:
                return("hh");

            case DateParts.Minute:
                return("mi");

            case DateParts.Second:
                return("ss");

            default:
                return(string.Empty);
            }
        }
示例#19
0
        private object dateTimePart(DateTime dt, DateParts dateParts)
        {
            switch ((int)dateParts)
            {
            case (int)DateParts.dateTime:
                return(dt);

            case (int)DateParts.date:
                return(dt.Date);

            case (int)DateParts.dateInt:
                return(ToolGeneral.date2IntDate(dt));

            case (int)DateParts.timeInt:
                return(ToolGeneral.time2IntTime(dt));

            case (int)DateParts.year:
                return(dt.Year);

            case (int)DateParts.month:
                return(dt.Month);

            case (int)DateParts.day:
                return(dt.Day);

            case (int)DateParts.hour:
                return(dt.Hour);

            case (int)DateParts.minute:
                return(dt.Minute);

            case (int)DateParts.second:
                return(dt.Second);
            }
            return(typeof(object));
        }
示例#20
0
 public virtual string FormatDate(DateParts parts)
 {
     return(FormatDate(parts, _dateTimeFormatProvider.ShortDateFormat));
 }
示例#21
0
 public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
 {
     if (bindingContext.ModelType == typeof(ModelBindViewModel))
     {
         bool               validDate = true;
         DateParts          dateParts = new DateParts();
         ModelBindViewModel result    = new ModelBindViewModel();
         var Request = controllerContext.HttpContext.Request;
         int outVal;
         if (int.TryParse(Request["Day"], out outVal))
         {
             dateParts.Day = outVal;
         }
         else
         {
             validDate = false;
         }
         if (int.TryParse(Request["Month"], out outVal))
         {
             dateParts.Month = outVal;
         }
         else
         {
             validDate = false;
         }
         if (int.TryParse(Request["Year"], out outVal))
         {
             dateParts.Year = outVal;
         }
         else
         {
             validDate = false;
         }
         DateTime mydate = new DateTime();
         if (validDate)
         {
             try
             {
                 mydate = new DateTime(dateParts.Year, dateParts.Month, dateParts.Day);
             }
             catch
             {
                 validDate = false;
             }
         }
         if (validDate)
         {
             result.InputDate = mydate;
             result.DateParts = dateParts;
         }
         else
         {
             bindingContext.ModelState.AddModelError("ModelBinding", "Invalid Input Date");
         }
         return(result);
     }
     else
     {
         return(base.BindModel(controllerContext, bindingContext));
     }
 }
 public string DatePart(DateParts dp, string targetColumn)
 {
     return(string.Format(datePart, dp.ToQuery(), targetColumn));
 }
示例#23
0
 public DateTimeUnit(DateParts datePart, int units)
 {
     this.DatePart = datePart;
     this.Units = units;
 }
示例#24
0
 public DateAddFunctionView(DateParts type)
 {
     Type = type;
 }
示例#25
0
 public DateAddFunctionView(DateParts type)
 {
     Type = type;
 }
示例#26
0
文件: DateAdd.cs 项目: jgshort/SqlDom
 public static DateAdd DateAddInt(DateParts datePart, int number)
 {
     return DateAddByGetDate(datePart, Sql.Integer(number));
 }
 public static DatePartValidator GetDatePartValidator(DateParts datePart)
 {
     return(datePartsMap[datePart].Invoke());
 }
示例#28
0
文件: DateAdd.cs 项目: jgshort/SqlDom
 public static DateAdd DateAddByGetDate(DateParts datePart, Expression number)
 {
     return new DateAdd(datePart, number, new GetDate());
 }
        private static Expression CreateDateRangeFilter(Expression valueExpr, DateParts start, DateParts end)
        {
            // both sides can't both be blank
            if (start.Blank && end.Blank)
            {
                return(null);
            }

            // start must either be blank or enough to be a specific date
            if (!(start.Blank || start.HasMonthAndDay))
            {
                return(null);
            }

            // end must either be blank or enough to be a specific date
            if (!(end.Blank || end.HasMonthAndDay))
            {
                return(null);
            }

            DateTime?startDate = (start.HasMonthAndDay) ? start.BestFitDate : null;
            DateTime?endDate   = (end.HasMonthAndDay) ? end.BestFitDate : null;

            // try to fix the dates if end is on or before start
            if (startDate.HasValue && endDate.HasValue && startDate >= endDate)
            {
                if (start.HasMonthDayYear && end.HasMonthDayYear)
                {
                    // swap dates
                    var temp = startDate;
                    startDate = endDate;
                    endDate   = temp;
                }
                else if (!start.HasMonthDayYear && !end.HasMonthDayYear)
                {
                    // add a year to end
                    endDate = endDate.Value.AddYears(1);
                }
            }

            Expression startExpr = null;

            if (startDate.HasValue)
            {
                startExpr = Expression.GreaterThanOrEqual(valueExpr, Expression.Constant(startDate.Value));
            }

            Expression endExpr = null;

            if (endDate.HasValue)
            {
                endExpr = Expression.LessThanOrEqual(valueExpr, Expression.Constant(endDate.Value));
            }

            Expression combined = null;

            if (startExpr != null)
            {
                combined = (combined == null) ? startExpr : Expression.And(combined, startExpr);
            }
            if (endExpr != null)
            {
                combined = (combined == null) ? endExpr : Expression.And(combined, endExpr);
            }

            return(combined);
        }
        private static bool TryParseDate(string dateString, out DateParts dateParts)
        {
            if (dateString == null)
            {
                throw new ArgumentNullException("dateString");
            }

            dateParts = new DateParts();

            if (string.IsNullOrEmpty(dateString))
            {
                return(true);
            }

            // split the string on slashes; exit if too many parts
            string[] parts = dateString.Split('/');
            if (parts.Length > 3)
            {
                return(false);
            }

            var result = new DateParts();

            // parse month component (must exist to get here)
            int mm;

            if (!int.TryParse(parts[0], out mm))
            {
                return(false);
            }
            int?month = mm;

            // parse day component if provided
            int?day = null;

            if (parts.Length > 1)
            {
                if (parts[1].Length > 0)
                {
                    int dd;
                    if (!int.TryParse(parts[1], out dd))
                    {
                        return(false);
                    }
                    day = dd;
                }
            }

            // parse year component if provided
            int?year = null;

            if (parts.Length > 2)
            {
                if (parts[2].Length > 0)
                {
                    int yy;
                    if (!int.TryParse(parts[2], out yy))
                    {
                        return(false);
                    }
                    year = yy;
                }
            }

            // build and a test string to verify components (and resolve 2-digit years)
            string dateStr = month.Value + "/" + (day ?? 1) + (year.HasValue ? "/" + year.Value : null);

            // try to parse the constructed date
            DateTime bestFitDate;

            if (!DateTime.TryParse(dateStr, out bestFitDate))
            {
                return(false);
            }

            // return the results
            dateParts = new DateParts()
            {
                Month = month, Day = day, Year = year, BestFitDate = bestFitDate
            };
            return(true);
        }
示例#31
0
        public DateInformation(DM.DateInformation dateInformation)
        {
            Initialize();

            if (dateInformation != null)
            {
                switch (dateInformation.DateType)
                {
                case DE.DateType.Unknown:
                    // Do Nothing
                    break;

                case DE.DateType.ExactFull:
                    List <string> dateFullParts = new List <string>();
                    if (dateInformation.DateExact.HasValue)
                    {
                        dateFullParts.Add(dateInformation.DateExact.Value.Year.ToString());
                        dateFullParts.Add(dateInformation.DateExact.Value.Month.ToString());
                        dateFullParts.Add(dateInformation.DateExact.Value.Day.ToString());
                    }
                    DateParts.Add(dateFullParts);
                    break;

                case DE.DateType.ExactPartial:
                    List <string> datePartialParts = new List <string>();
                    if (dateInformation.Year.HasValue)
                    {
                        datePartialParts.Add(dateInformation.Year.Value.ToString());
                    }
                    if (dateInformation.Month.HasValue)
                    {
                        datePartialParts.Add(dateInformation.Month.Value.ToString());
                    }
                    if (dateInformation.Day.HasValue)
                    {
                        datePartialParts.Add(dateInformation.Day.Value.ToString());
                    }
                    DateParts.Add(datePartialParts);
                    if (!string.IsNullOrEmpty(dateInformation.Season))
                    {
                        Season = dateInformation.Season;
                    }
                    if (dateInformation.IsApproximate)
                    {
                        Circa = "1";
                    }
                    break;

                case DE.DateType.RangeFull:
                    List <string> dateFullMinParts = new List <string>();
                    if (dateInformation.DateMin.HasValue)
                    {
                        dateFullMinParts.Add(dateInformation.DateMin.Value.Year.ToString());
                        dateFullMinParts.Add(dateInformation.DateMin.Value.Month.ToString());
                        dateFullMinParts.Add(dateInformation.DateMin.Value.Day.ToString());
                    }
                    DateParts.Add(dateFullMinParts);
                    List <string> dateFullMaxParts = new List <string>();
                    if (dateInformation.DateMax.HasValue)
                    {
                        dateFullMaxParts.Add(dateInformation.DateMax.Value.Year.ToString());
                        dateFullMaxParts.Add(dateInformation.DateMax.Value.Month.ToString());
                        dateFullMaxParts.Add(dateInformation.DateMax.Value.Day.ToString());
                    }
                    DateParts.Add(dateFullMaxParts);
                    break;

                case DE.DateType.RangePartial:
                    List <string> datePartialMinParts = new List <string>();
                    if (dateInformation.YearMin.HasValue)
                    {
                        datePartialMinParts.Add(dateInformation.YearMin.Value.ToString());
                    }
                    if (dateInformation.MonthMin.HasValue)
                    {
                        datePartialMinParts.Add(dateInformation.MonthMin.Value.ToString());
                    }
                    if (dateInformation.DayMin.HasValue)
                    {
                        datePartialMinParts.Add(dateInformation.DayMin.Value.ToString());
                    }
                    DateParts.Add(datePartialMinParts);
                    List <string> datePartialMaxParts = new List <string>();
                    if (dateInformation.YearMax.HasValue)
                    {
                        datePartialMaxParts.Add(dateInformation.YearMax.Value.ToString());
                    }
                    if (dateInformation.MonthMax.HasValue)
                    {
                        datePartialMaxParts.Add(dateInformation.MonthMax.Value.ToString());
                    }
                    if (dateInformation.DayMax.HasValue)
                    {
                        datePartialMaxParts.Add(dateInformation.DayMax.Value.ToString());
                    }
                    DateParts.Add(datePartialMaxParts);
                    break;

                case DE.DateType.Literal:
                    if (!string.IsNullOrEmpty(dateInformation.Literal))
                    {
                        Literal = dateInformation.Literal;
                    }
                    break;

                default:
                    throw new NotImplementedException();
                }
            }
        }
        public void FormatDateTest01()
        {
            var allCases       = new ConcurrentBag <string>();
            var failedCases    = new ConcurrentDictionary <string, Exception>();
            var maxFailedCases = 0;

            var options = new ParallelOptions();

            if (Debugger.IsAttached)
            {
                options.MaxDegreeOfParallelism = 1;
            }

            var allCultures = CultureInfo.GetCultures(CultureTypes.AllCultures);

            Parallel.ForEach(allCultures, options, culture => { // All cultures on the machine.
                var container = TestHelpers.InitializeContainer(culture.Name, "GregorianCalendar", TimeZoneInfo.Utc);
                var formats   = container.Resolve <IDateTimeFormatProvider>();
                var target    = container.Resolve <IDateFormatter>();

                foreach (var dateFormat in formats.AllDateFormats) // All date formats supported by the culture.
                {
                    for (var month = 1; month <= 12; month++)      // All months in the year.

                    {
                        DateTime date       = new DateTime(1998, month, 1);
                        DateParts dateParts = new DateParts(1998, month, 1);

                        // Print reference string using Gregorian calendar to avoid calendar conversion.
                        var cultureGregorian = (CultureInfo)culture.Clone();
                        cultureGregorian.DateTimeFormat.Calendar = cultureGregorian.OptionalCalendars.OfType <GregorianCalendar>().First();

                        var caseKey = String.Format("{0}___{1}___{2}", culture.Name, dateFormat, dateParts);
                        allCases.Add(caseKey);
                        //Debug.WriteLine(String.Format("{0} cases tested so far. Testing case {1}...", allCases.Count, caseKey));

                        try {
                            var result   = target.FormatDate(dateParts, dateFormat);
                            var expected = date.ToString(dateFormat, cultureGregorian);
                            if (result != expected)
                            {
                                // The .NET date formatting logic contains a bug that causes it to recognize 'd' and 'dd'
                                // as numerical day specifiers even when they are embedded in literals. Our implementation
                                // does not contain this bug. If we encounter an unexpected result and the .NET reference
                                // result contains the genitive month name, replace it with the non-genitive month name
                                // before asserting.
                                var numericalDayPattern  = @"(\b|[^d])d{1,2}(\b|[^d])";
                                var containsNumericalDay = Regex.IsMatch(dateFormat, numericalDayPattern);
                                if (containsNumericalDay)
                                {
                                    var monthName         = formats.MonthNames[month - 1];
                                    var monthNameGenitive = formats.MonthNamesGenitive[month - 1];
                                    expected = expected.Replace(monthNameGenitive, monthName);
                                }
                            }
                            Assert.AreEqual(expected, result);
                        }
                        catch (Exception ex) {
                            failedCases.TryAdd(caseKey, ex);
                        }
                    }
                }
            });

            if (failedCases.Count > maxFailedCases)
            {
                throw new AggregateException(String.Format("Format tests failed for {0} of {1} cases. Expected {2} failed cases or less.", failedCases.Count, allCases.Count, maxFailedCases), failedCases.Values);
            }
        }
示例#33
0
文件: DateAdd.cs 项目: jgshort/SqlDom
 public static DateAdd DateAddInt(DateParts datePart, int number, Expression date)
 {
     return new DateAdd(datePart, Sql.Integer(number), date);
 }
示例#34
0
 public DateDiffFuncionView1(DateParts type)
 {
     Type = type;
 }
示例#35
0
 public DateDiffFuncionView1(DateParts type)
 {
     Type = type;
 }