/// <summary> /// Returns an object of the specified type and whose value is equivalent to the specified object. /// </summary> /// <typeparam name="TValue">The type of object to return.</typeparam> /// <param name="value">An object that implements the <see cref="IConvertible"/> interface.</param> /// <param name="result">New instance of object whose value is equivalent to the specified object.</param> /// <param name="cultureInfo">Culture info to use for conversion.</param> /// <returns>True if conversion was successful.</returns> public static bool TryChangeType <TValue>(object value, out TValue result, CultureInfo cultureInfo = null) { try { Type conversionType = Nullable.GetUnderlyingType(typeof(TValue)) ?? typeof(TValue); if (conversionType.IsEnum && EnumTryParse(value?.ToString(), conversionType, out TValue theEnum)) { result = theEnum; } else if (conversionType == typeof(Guid)) { result = (TValue)Convert.ChangeType(Guid.Parse(value.ToString()), conversionType); } else if (conversionType == typeof(DateOnly)) { result = (TValue)Convert.ChangeType(DateOnly.Parse(value.ToString()), conversionType); } else if (conversionType == typeof(DateTimeOffset)) { result = (TValue)Convert.ChangeType(DateTimeOffset.Parse(value.ToString()), conversionType); } else { result = (TValue)Convert.ChangeType(value, conversionType, cultureInfo ?? CultureInfo.InvariantCulture); } return(true); } catch { result = default; return(false); } }
[InlineData("9999-12-31")] // DateOnly.MaxValue public static void DateOnly_Write_Success(string value) { DateOnly ts = DateOnly.Parse(value); string json = JsonSerializer.Serialize(ts); Assert.Equal($"\"{value}\"", json); }
public static void OAndRFormatsTest() { DateOnly dateOnly = DateOnly.FromDateTime(DateTime.Today); string formattedDate = dateOnly.ToString("o"); Assert.Equal(10, formattedDate.Length); Assert.Equal('-', formattedDate[4]); Assert.Equal('-', formattedDate[7]); DateOnly parsedDateOnly = DateOnly.Parse(formattedDate); Assert.Equal(dateOnly, parsedDateOnly); parsedDateOnly = DateOnly.Parse(formattedDate.AsSpan()); Assert.Equal(dateOnly, parsedDateOnly); parsedDateOnly = DateOnly.ParseExact(formattedDate, "O"); Assert.Equal(dateOnly, parsedDateOnly); parsedDateOnly = DateOnly.ParseExact(formattedDate.AsSpan(), "O".AsSpan()); Assert.Equal(dateOnly, parsedDateOnly); formattedDate = dateOnly.ToString("r"); Assert.Equal(16, formattedDate.Length); Assert.Equal(',', formattedDate[3]); Assert.Equal(' ', formattedDate[4]); Assert.Equal(' ', formattedDate[7]); Assert.Equal(' ', formattedDate[11]); parsedDateOnly = DateOnly.Parse(formattedDate); Assert.Equal(dateOnly, parsedDateOnly); parsedDateOnly = DateOnly.Parse(formattedDate.AsSpan()); Assert.Equal(dateOnly, parsedDateOnly); parsedDateOnly = DateOnly.ParseExact(formattedDate, "R"); Assert.Equal(dateOnly, parsedDateOnly); parsedDateOnly = DateOnly.ParseExact(formattedDate.AsSpan(), "R".AsSpan()); Assert.Equal(dateOnly, parsedDateOnly); }
public static object?Parse(string value, Type type) { if (type == typeof(string)) { return((object)value); } if (value == null || value == "" || value == " ") { return((object?)null); } Type utype = type.UnNullify(); if (utype.IsEnum) { return(Enum.Parse(utype, (string)value)); } if (utype == typeof(Guid)) { return(Guid.Parse(value)); } if (utype == typeof(DateOnly)) { return(DateOnly.Parse(value)); } if (CustomParsers.TryGetValue(utype, out var func)) { return(func(value)); //Delay reference } return(Convert.ChangeType(value, utype)); }
public static T Parse <T>(string value) { if (typeof(T) == typeof(string)) { return((T)(object)value); } if (value == null || value == "") { return((T)(object?)null !); } Type utype = typeof(T).UnNullify(); if (utype.IsEnum) { return((T)Enum.Parse(utype, (string)value)); } if (utype == typeof(Guid)) { return((T)(object)Guid.Parse(value)); } if (utype == typeof(DateOnly)) { return((T)(object)DateOnly.Parse(value)); } return((T)Convert.ChangeType(value, utype) !); }
public override void ClassWithDateOnlyAndTimeOnlyValues_Roundtrip() { RunTest(new ClassWithDateOnlyAndTimeOnlyValues { DateOnly = DateOnly.Parse("2022-05-10"), NullableDateOnly = DateOnly.Parse("2022-05-10"), TimeOnly = TimeOnly.Parse("21:51:51"), NullableTimeOnly = TimeOnly.Parse("21:51:51"), }); RunTest(new ClassWithDateOnlyAndTimeOnlyValues()); void RunTest(ClassWithDateOnlyAndTimeOnlyValues expected) { string json = JsonSerializer.Serialize(expected, DefaultContext.ClassWithDateOnlyAndTimeOnlyValues); ClassWithDateOnlyAndTimeOnlyValues actual = JsonSerializer.Deserialize(json, ((ITestContext)MetadataWithPerTypeAttributeContext.Default).ClassWithDateOnlyAndTimeOnlyValues); Assert.Equal(expected.DateOnly, actual.DateOnly); Assert.Equal(expected.NullableDateOnly, actual.NullableDateOnly); Assert.Equal(expected.TimeOnly, actual.TimeOnly); Assert.Equal(expected.NullableTimeOnly, actual.NullableTimeOnly); } }
public void Values_can_be_correctly_converted_to_nullable_dateonly_without_the_parser_specifying_a_custom_converter() { var option = new Option <DateOnly?>("-x"); var value = option.Parse("-x 2022-03-02").GetValueForOption(option); value.Should().Be(DateOnly.Parse("2022-03-02")); }
public void Parse2([DataSources(DateOnlySkipProviders)] string context) { using (var db = GetDataContext(context)) using (db.CreateLocalTable(Transaction.AllData)) AreEqual( from d in from t in Transaction.AllData select DateOnly.Parse(Sql.ConvertTo <string> .From(t.TransactionDate)) where d.Day > 0 select d, from d in from t in db.GetTable <Transaction>() select DateOnly.Parse(Sql.ConvertTo <string> .From(t.TransactionDate)) where d.Day > 0 select d); }
[InlineData("9999-12-31")] // DateOnly.MaxValue public static void DateOnly_WriteDictionaryKey_Success(string value) { var dict = new Dictionary <DateOnly, int> { [DateOnly.Parse(value)] = 0 }; string json = JsonSerializer.Serialize(dict); Assert.Equal($@"{{""{value}"":0}}", json); }
public void can_get_dateonly_in_future() { var now = DateOnly.Parse("1/1/1990", CultureInfo.InvariantCulture); var maxDate = now.AddYears(1); var someFutureDate = date.FutureDateOnly(refDate: now); someFutureDate.Should().BeInRange(now, maxDate); }
public override DateOnly?ReadJson(JsonReader reader, Type objectType, DateOnly?existingValue, bool hasExistingValue, JsonSerializer serializer) { if (reader.Value is null) { return(null); } return(DateOnly.Parse(reader.Value as string ?? string.Empty, CultureInfo.InvariantCulture)); }
public void can_get_dateonly_in_past() { var now = DateOnly.Parse("7/7/1972", CultureInfo.InvariantCulture); var maxBehind = now.AddYears(-1); var somePastDate = date.PastDateOnly(refDate: now); somePastDate.Should().BeInRange(maxBehind, now); }
public void can_get_dateonly_recently_within_the_year() { var now = DateOnly.Parse("7/7/1972", CultureInfo.InvariantCulture); var maxBehind = now.AddDays(-1); var someRecentDate = date.RecentDateOnly(refDate: now); someRecentDate.Should().BeInRange(maxBehind, now); }
public void can_get_dateonly_in_future_with_options() { var now = DateOnly.Parse("7/7/1972", CultureInfo.InvariantCulture); var maxDate = now.AddYears(5); var someFutureDate = date.FutureDateOnly(5, now); someFutureDate.Should().BeInRange(now, maxDate); }
public void get_a_dateonly_that_will_happen_soon() { var now = DateOnly.Parse("7/7/1972", CultureInfo.InvariantCulture); var maxDate = now.AddDays(3); var someDateSoon = date.SoonDateOnly(3, now); someDateSoon.Should().BeInRange(now, maxDate); }
public void can_get_dateonly_in_past_with_custom_options() { var now = DateOnly.Parse("7/7/1972", CultureInfo.InvariantCulture); var maxBehind = now.AddYears(-5); var somePastDate = date.PastDateOnly(5, now); somePastDate.Should().BeInRange(maxBehind, now); }
/// <summary> /// 判断两个日期是否是在同一月 /// </summary> /// <param name="date1"></param> /// <param name="date2"></param> /// <returns></returns> public static bool IsMonthSame(String date1, String date2) { DateOnly dt1 = DateOnly.Parse(date1); DateOnly dt2 = DateOnly.Parse(date2); int temp1 = dt1.Month; int temp2 = dt2.Month; bool result = temp1 == temp2; return(result); }
/// <summary> /// 判断两个日期是否是在同一周 /// </summary> /// <param name="date1"></param> /// <param name="date2"></param> /// <returns></returns> public static bool IsWeekSame(String date1, String date2) { DateOnly dt1 = DateOnly.Parse(date1); DateOnly dt2 = DateOnly.Parse(date2); DateOnly temp1 = dt1.AddDays(-(int)dt1.DayOfWeek); DateOnly temp2 = dt2.AddDays(-(int)dt2.DayOfWeek); bool result = temp1 == temp2; return(result); }
public void Parse1([DataSources(DateOnlySkipProviders)] string context) { using var db = GetDataContext(context); using var table = db.CreateLocalTable(Transaction.AllData); var query = from t in db.GetTable <Transaction>() let d = DateOnly.Parse("2010-01-" + Sql.ZeroPad(t.TransactionId, 2)) where d.Day > 0 select d; AssertQuery(query); }
public virtual DateOnly GetDateOnly(int ordinal) { var sqliteType = GetSqliteType(ordinal); switch (sqliteType) { case SQLITE_FLOAT: case SQLITE_INTEGER: return(DateOnly.FromDateTime(FromJulianDate(GetDouble(ordinal)))); default: return(DateOnly.Parse(GetString(ordinal), CultureInfo.InvariantCulture)); } }
public void can_get_random_dateonly_between_two_dates() { var start = DateOnly.Parse("8/8/2020", CultureInfo.InvariantCulture); var end = DateOnly.Parse("12/12/2021", CultureInfo.InvariantCulture); var someDate = date.BetweenDateOnly(start, end); someDate.Should().BeInRange(start, end); //and reverse... var otherDate = date.BetweenDateOnly(end, start); otherDate.Should().BeInRange(start, end); }
/// <summary> /// Converts the string to an object. /// </summary> /// <param name="text">The string to convert to an object.</param> /// <param name="row">The <see cref="IReaderRow"/> for the current record.</param> /// <param name="memberMapData">The <see cref="MemberMapData"/> for the member being created.</param> /// <returns>The object created from the string.</returns> public override object ConvertFromString(string text, IReaderRow row, MemberMapData memberMapData) { if (text == null) { return(base.ConvertFromString(null, row, memberMapData)); } var formatProvider = (IFormatProvider)memberMapData.TypeConverterOptions.CultureInfo.GetFormat(typeof(DateTimeFormatInfo)) ?? memberMapData.TypeConverterOptions.CultureInfo; var dateTimeStyle = memberMapData.TypeConverterOptions.DateTimeStyle ?? DateTimeStyles.None; return(memberMapData.TypeConverterOptions.Formats == null || memberMapData.TypeConverterOptions.Formats.Length == 0 ? DateOnly.Parse(text, formatProvider, dateTimeStyle) : DateOnly.ParseExact(text, memberMapData.TypeConverterOptions.Formats, formatProvider, dateTimeStyle)); }
public static void InvalidFormatsTest() { DateTime dt = DateTime.Now; string formatted = dt.ToString(); Assert.Throws <FormatException>(() => DateOnly.Parse(formatted)); Assert.Throws <FormatException>(() => DateOnly.Parse(formatted.AsSpan())); Assert.False(DateOnly.TryParse(formatted, out DateOnly dateOnly)); Assert.False(DateOnly.TryParse(formatted.AsSpan(), out dateOnly)); formatted = dt.ToString("t"); Assert.Throws <FormatException>(() => DateOnly.Parse(formatted)); Assert.Throws <FormatException>(() => DateOnly.Parse(formatted.AsSpan())); Assert.False(DateOnly.TryParse(formatted, out dateOnly)); Assert.False(DateOnly.TryParse(formatted.AsSpan(), out dateOnly)); }
public async Task GetDatesFromRange_OnNewYear_ShouldReturn3Records() { var context = CreateContext(); var(_, records) = await AddTestData(context); var datesService = GetDatesService(5, context); var list = await datesService.GetDatesFromRange(new DateOnly(2020, 01, 01), false); list.Should().HaveCount(2); list.Should().SatisfyRespectively( first => first.Date.Should().Be(DateOnly.Parse("2019-12-31")), second => second.Date.Should().Be(DateOnly.Parse("2018-01-01"))); }
public async Task DateOnlyValueTest() { var expected = "2000-10-12"; DateOnly?value = null; using var ctx = new TestContext(); var cut = ctx.RenderComponent <BSInput <DateOnly?> >(parameters => parameters.Add(p => p.Value, value) .Add(p => p.ValueChanged, e => { value = e; }) ); cut.Find("input").Change(expected); Assert.Equal(DateOnly.Parse(expected), value); }
public async Task DateOnlyValueTest() { var expected = DateOnly.Parse("2000-10-20"); var value = DateOnly.Parse("2020-10-20"); using var ctx = new TestContext(); var cut = ctx.RenderComponent <BSInputCheckbox <DateOnly> >(parameters => parameters.Add(p => p.Value, value) .Add(p => p.CheckedValue, DateOnly.Parse("2000-10-20")) .Add(p => p.UnCheckedValue, DateOnly.Parse("2020-10-20")) .Add(p => p.ValueChanged, e => { value = e; }) ); cut.Find("input").Click(); Assert.Equal(expected, value); cut.Find("input").Click(); Assert.Equal(DateOnly.Parse("2020-10-20"), value); }
public async Task GetDatesFromRange_ShouldReturn1Records_Then2Records() { var context = CreateContext(); await AddTestData(context); var datesService = GetDatesService(5, context); var list = await datesService.GetDatesFromRange(new DateOnly(2020, 04, 28), false); list.Should().HaveCount(1); list[0].Date.Should().Be(DateOnly.Parse("2012-04-23")); //============================// list = await datesService.GetDatesFromRange(new DateOnly(2020, 06, 19), false); list.Should().HaveCount(2); var expected = new string[] { "2019-06-23", "2015-06-23" }.Select(t => DateOnly.Parse(t)).ToList(); list.Select(i => i.Date).Should().OnlyContain(d => expected.Contains(d)); }
private static async Task Run(Options option) { Program.pseGetOption = option; var fromDate = DateOnly.FromDateTime(DateTime.Today); var toDate = DateOnly.FromDateTime(DateTime.Today); if (!option.DateRange.Equals("today", StringComparison.OrdinalIgnoreCase)) { var dateRange = option.DateRange.Split(':'); if (dateRange.Length == 0) { throw new Exception($"{option.DateRange} is not a valid date range."); } fromDate = DateOnly.Parse(dateRange[0].Trim()); toDate = DateOnly.Parse(dateRange[1].Trim()); if (toDate < fromDate) { throw new Exception("Invalid date range."); } } var downloadDate = fromDate; while (downloadDate <= toDate) { var pdfBytes = await DownloadReport(downloadDate); if (pdfBytes != null) { Log.Information($"Converting to CSV..."); await ConvertPdfBytesToCsv(pdfBytes, downloadDate); Log.Information("Done."); } downloadDate = downloadDate.AddDays(1); } Log.Information("Download complete."); }
public static void BasicFormatParseTest() { DateOnly dateOnly = DateOnly.FromDateTime(DateTime.Today); string s = dateOnly.ToString(); DateOnly parsedDateOnly = DateOnly.Parse(s); Assert.True(DateOnly.TryParse(s, out DateOnly parsedDateOnly1)); Assert.Equal(dateOnly, parsedDateOnly); Assert.Equal(dateOnly, parsedDateOnly1); parsedDateOnly = DateOnly.Parse(s.AsSpan()); Assert.True(DateOnly.TryParse(s.AsSpan(), out parsedDateOnly1)); Assert.Equal(dateOnly, parsedDateOnly); Assert.Equal(dateOnly, parsedDateOnly1); s = dateOnly.ToString(CultureInfo.InvariantCulture); parsedDateOnly = DateOnly.Parse(s, CultureInfo.InvariantCulture); Assert.True(DateOnly.TryParse(s.AsSpan(), CultureInfo.InvariantCulture, DateTimeStyles.None, out parsedDateOnly1)); Assert.Equal(dateOnly, parsedDateOnly); Assert.Equal(dateOnly, parsedDateOnly1); parsedDateOnly = DateOnly.Parse(s.AsSpan(), CultureInfo.InvariantCulture); Assert.True(DateOnly.TryParse(s.AsSpan(), CultureInfo.InvariantCulture, DateTimeStyles.None, out parsedDateOnly1)); Assert.Equal(dateOnly, parsedDateOnly); Assert.Equal(dateOnly, parsedDateOnly1); Assert.False(DateOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out parsedDateOnly1)); Assert.Throws <ArgumentException>(() => DateOnly.Parse(s, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal)); Assert.False(DateOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out parsedDateOnly1)); Assert.Throws <ArgumentException>(() => DateOnly.Parse(s, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal)); Assert.False(DateOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out parsedDateOnly1)); Assert.Throws <ArgumentException>(() => DateOnly.Parse(s, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal)); Assert.False(DateOnly.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.NoCurrentDateDefault, out parsedDateOnly1)); Assert.Throws <ArgumentException>(() => DateOnly.Parse(s, CultureInfo.InvariantCulture, DateTimeStyles.NoCurrentDateDefault)); s = " " + s + " "; parsedDateOnly = DateOnly.Parse(s, CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces); Assert.Equal(dateOnly, parsedDateOnly); parsedDateOnly = DateOnly.Parse(s.AsSpan(), CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces); Assert.Equal(dateOnly, parsedDateOnly); }
/// <summary> /// Converts the given value object to a <see cref='System.DateOnly'/> object. /// </summary> /// <inheritdoc /> public override object?ConvertFrom(ITypeDescriptorContext?context, CultureInfo?culture, object value) { if (value is string text) { text = text.Trim(); if (text.Length == 0) { return(DateOnly.MinValue); } try { // See if we have a culture info to parse with. If so, then use it. DateTimeFormatInfo?formatInfo = null; if (culture != null) { formatInfo = (DateTimeFormatInfo?)culture.GetFormat(typeof(DateTimeFormatInfo)); } if (formatInfo != null) { return(DateOnly.Parse(text, formatInfo)); } else { return(DateOnly.Parse(text, culture)); } } catch (FormatException e) { throw new FormatException(SR.Format(SR.ConvertInvalidPrimitive, (string)value, nameof(DateOnly)), e); } } return(base.ConvertFrom(context, culture, value)); }