/// <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)); }
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); }
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); }
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); }
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(); }
public DateAdd(DateParts datePart, Expression number, Expression date) : base(null) { DatePart = datePart; Number = number; Date = date; }
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)); }
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(); }
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(); }
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; }
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)); }
/// <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); }
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); }
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(), });
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}") });
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(), });
/// <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); } }
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)); }
public virtual string FormatDate(DateParts parts) { return(FormatDate(parts, _dateTimeFormatProvider.ShortDateFormat)); }
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)); }
public DateTimeUnit(DateParts datePart, int units) { this.DatePart = datePart; this.Units = units; }
public DateAddFunctionView(DateParts type) { Type = type; }
public static DateAdd DateAddInt(DateParts datePart, int number) { return DateAddByGetDate(datePart, Sql.Integer(number)); }
public static DatePartValidator GetDatePartValidator(DateParts datePart) { return(datePartsMap[datePart].Invoke()); }
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); }
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); } }
public static DateAdd DateAddInt(DateParts datePart, int number, Expression date) { return new DateAdd(datePart, Sql.Integer(number), date); }
public DateDiffFuncionView1(DateParts type) { Type = type; }