Add support for .NET 6 DateOnly/TimeOnly data types

mythz · mythz · commit 6463f0038535 · 2021-11-10T20:36:46.000+08:00
diff --git a/src/ServiceStack.Text/Common/DeserializeBuiltin.cs b/src/ServiceStack.Text/Common/DeserializeBuiltin.cs
@@ -74,6 +74,12 @@ private static ParseStringSpanDelegate GetParseStringSpanFn()
                     return value => DateTimeSerializer.ParseDateTimeOffset(value.ToString());
                 if (typeof(T) == typeof(TimeSpan))
                     return value => DateTimeSerializer.ParseTimeSpan(value.ToString());
+#if NET6_0 
+                if (typeof(T) == typeof(DateOnly))
+                    return value => DateOnly.FromDateTime(DateTimeSerializer.ParseShortestXsdDateTime(value.ToString()));
+                if (typeof(T) == typeof(TimeOnly))
+                    return value => TimeOnly.FromTimeSpan(DateTimeSerializer.ParseTimeSpan(value.ToString()));
+#endif
             }
             else
             {
@@ -119,6 +125,12 @@ private static ParseStringSpanDelegate GetParseStringSpanFn()
                     return value => value.IsNullOrEmpty() ? (Guid?)null : value.ParseGuid();
                 if (typeof(T) == typeof(DateTimeOffset?))
                     return value => DateTimeSerializer.ParseNullableDateTimeOffset(value.ToString());
+#if NET6_0 
+                if (typeof(T) == typeof(DateOnly?))
+                    return value => value.IsNullOrEmpty() ? default : DateOnly.FromDateTime(DateTimeSerializer.ParseShortestXsdDateTime(value.ToString()));
+                if (typeof(T) == typeof(TimeOnly?))
+                    return value => value.IsNullOrEmpty() ? default : TimeOnly.FromTimeSpan(DateTimeSerializer.ParseTimeSpan(value.ToString()));
+#endif
             }
 
             return null;
diff --git a/src/ServiceStack.Text/Common/ITypeSerializer.cs b/src/ServiceStack.Text/Common/ITypeSerializer.cs
@@ -30,8 +30,8 @@ public interface ITypeSerializer
         void WriteNullableDateTime(TextWriter writer, object dateTime);
         void WriteDateTimeOffset(TextWriter writer, object oDateTimeOffset);
         void WriteNullableDateTimeOffset(TextWriter writer, object dateTimeOffset);
-        void WriteTimeSpan(TextWriter writer, object dateTimeOffset);
-        void WriteNullableTimeSpan(TextWriter writer, object dateTimeOffset);
+        void WriteTimeSpan(TextWriter writer, object timeSpan);
+        void WriteNullableTimeSpan(TextWriter writer, object timeSpan);
         void WriteGuid(TextWriter writer, object oValue);
         void WriteNullableGuid(TextWriter writer, object oValue);
         void WriteBytes(TextWriter writer, object oByteValue);
@@ -50,6 +50,13 @@ public interface ITypeSerializer
         void WriteDecimal(TextWriter writer, object decimalValue);
         void WriteEnum(TextWriter writer, object enumValue);
 
+#if NET6_0_OR_GREATER
+        void WriteDateOnly(TextWriter writer, object oDateOnly);
+        void WriteNullableDateOnly(TextWriter writer, object oDateOnly);
+        void WriteTimeOnly(TextWriter writer, object oTimeOnly);
+        void WriteNullableTimeOnly(TextWriter writer, object oTimeOnly);
+#endif
+
         ParseStringDelegate GetParseFn<T>();
         ParseStringSpanDelegate GetParseStringSpanFn<T>();
         ParseStringDelegate GetParseFn(Type type);
diff --git a/src/ServiceStack.Text/Common/JsWriter.cs b/src/ServiceStack.Text/Common/JsWriter.cs
@@ -278,6 +278,24 @@ public WriteObjectDelegate GetValueTypeToStringMethod(Type type)
 
                 if (type == typeof(Guid?))
                     return Serializer.WriteNullableGuid;
+
+#if NET6_0
+                if (type == typeof(DateOnly))
+                    if (isNullable)
+                        return Serializer.WriteNullableDateOnly;
+                    else
+                        return Serializer.WriteDateOnly;
+                if (type == typeof(DateOnly?))
+                    return Serializer.WriteDateOnly;
+                
+                if (type == typeof(TimeOnly))
+                    if (isNullable)
+                        return Serializer.WriteNullableTimeOnly;
+                    else
+                        return Serializer.WriteTimeOnly;
+                if (type == typeof(TimeOnly?))
+                    return Serializer.WriteTimeOnly;
+#endif
             }
             else
             {
diff --git a/src/ServiceStack.Text/DateTimeExtensions.cs b/src/ServiceStack.Text/DateTimeExtensions.cs
@@ -76,6 +76,11 @@ public static long ToUnixTimeMs(this long ticks)
             return (ticks - UnixEpoch) / TimeSpan.TicksPerMillisecond;
         }
 
+#if NET6_0
+        public static long ToUnixTimeMs(this DateOnly dateOnly) => dateOnly.ToDateTime(default, DateTimeKind.Utc).ToUnixTimeMs(); 
+        public static long ToUnixTime(this DateOnly dateOnly) => dateOnly.ToDateTime(default, DateTimeKind.Utc).ToUnixTime(); 
+#endif
+
         public static DateTime FromUnixTimeMs(this double msSince1970)
         {
             return UnixEpochDateTimeUtc + TimeSpan.FromMilliseconds(msSince1970);
diff --git a/src/ServiceStack.Text/Json/JsonTypeSerializer.cs b/src/ServiceStack.Text/Json/JsonTypeSerializer.cs
@@ -138,7 +138,6 @@ public void WriteTimeSpan(TextWriter writer, object oTimeSpan)
 
         public void WriteNullableTimeSpan(TextWriter writer, object oTimeSpan)
         {
-
             if (oTimeSpan == null) return;
             WriteTimeSpan(writer, ((TimeSpan?)oTimeSpan).Value);
         }
@@ -289,6 +288,50 @@ public void WriteEnum(TextWriter writer, object enumValue)
                 JsWriter.WriteEnumFlags(writer, enumValue);
         }
 
+
+#if NET6_0
+        public void WriteDateOnly(TextWriter writer, object oDateOnly)
+        {
+            var dateOnly = (DateOnly)oDateOnly;
+            switch (JsConfig.DateHandler)
+            {
+                case DateHandler.UnixTime:
+                    writer.Write(dateOnly.ToUnixTime());
+                    break;
+                case DateHandler.UnixTimeMs:
+                    writer.Write(dateOnly.ToUnixTimeMs());
+                    break;
+                default:
+                    writer.Write(JsWriter.QuoteString);
+                    writer.Write(dateOnly.ToString("O"));
+                    writer.Write(JsWriter.QuoteString);
+                    break;
+            }
+        }
+
+        public void WriteNullableDateOnly(TextWriter writer, object oDateOnly)
+        {
+            if (oDateOnly == null)
+                writer.Write(JsonUtils.Null);
+            else
+                WriteDateOnly(writer, oDateOnly);
+        }
+
+        public void WriteTimeOnly(TextWriter writer, object oTimeOnly)
+        {
+            var stringValue = JsConfig.TimeSpanHandler == TimeSpanHandler.StandardFormat
+                ? oTimeOnly.ToString()
+                : DateTimeSerializer.ToXsdTimeSpanString(((TimeOnly)oTimeOnly).ToTimeSpan());
+            WriteRawString(writer, stringValue);
+        }
+
+        public void WriteNullableTimeOnly(TextWriter writer, object oTimeOnly)
+        {
+            if (oTimeOnly == null) return;
+            WriteTimeSpan(writer, ((TimeOnly?)oTimeOnly).Value.ToTimeSpan());
+        }
+#endif        
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ParseStringDelegate GetParseFn<T>()
         {
diff --git a/src/ServiceStack.Text/Jsv/JsvTypeSerializer.cs b/src/ServiceStack.Text/Jsv/JsvTypeSerializer.cs
@@ -248,6 +248,45 @@ public void WriteEnum(TextWriter writer, object enumValue)
                 JsWriter.WriteEnumFlags(writer, enumValue);
         }
 
+#if NET6_0
+        public void WriteDateOnly(TextWriter writer, object oDateOnly)
+        {
+            var dateOnly = (DateOnly)oDateOnly;
+            switch (JsConfig.DateHandler)
+            {
+                case DateHandler.UnixTime:
+                    writer.Write(dateOnly.ToUnixTime());
+                    break;
+                case DateHandler.UnixTimeMs:
+                    writer.Write(dateOnly.ToUnixTimeMs());
+                    break;
+                default:
+                    writer.Write(dateOnly.ToString("O"));
+                    break;
+            }
+        }
+
+        public void WriteNullableDateOnly(TextWriter writer, object oDateOnly)
+        {
+            if (oDateOnly == null) return;
+            WriteDateOnly(writer, oDateOnly);
+        }
+
+        public void WriteTimeOnly(TextWriter writer, object oTimeOnly)
+        {
+            var stringValue = JsConfig.TimeSpanHandler == TimeSpanHandler.StandardFormat
+                ? oTimeOnly.ToString()
+                : DateTimeSerializer.ToXsdTimeSpanString(((TimeOnly)oTimeOnly).ToTimeSpan());
+            WriteRawString(writer, stringValue);
+        }
+
+        public void WriteNullableTimeOnly(TextWriter writer, object oTimeOnly)
+        {
+            if (oTimeOnly == null) return;
+            WriteTimeSpan(writer, ((TimeOnly?)oTimeOnly).Value.ToTimeSpan());
+        }
+#endif        
+
         public ParseStringDelegate GetParseFn<T>() => JsvReader.Instance.GetParseFn<T>();
 
         public ParseStringDelegate GetParseFn(Type type) => JsvReader.GetParseFn(type);
diff --git a/tests/ServiceStack.Text.Tests/Net6TypeTests.cs b/tests/ServiceStack.Text.Tests/Net6TypeTests.cs
@@ -0,0 +1,138 @@
+using System;
+using NUnit.Framework;
+
+#if NET6_0
+namespace ServiceStack.Text.Tests;
+
+public class DateOnlyDto
+{
+    public DateOnly Date { get; set; }
+
+    protected bool Equals(DateOnlyDto other) => Date.Equals(other.Date);
+    public override bool Equals(object obj)
+    {
+        if (ReferenceEquals(null, obj)) return false;
+        if (ReferenceEquals(this, obj)) return true;
+        if (obj.GetType() != this.GetType()) return false;
+        return Equals((DateOnlyDto)obj);
+    }
+    public override int GetHashCode() => Date.GetHashCode();
+}
+
+public class TimeOnlyDto
+{
+    public TimeOnly Time { get; set; }
+
+    protected bool Equals(TimeOnlyDto other) => Time.Equals(other.Time);
+    public override bool Equals(object obj)
+    {
+        if (ReferenceEquals(null, obj)) return false;
+        if (ReferenceEquals(this, obj)) return true;
+        if (obj.GetType() != this.GetType()) return false;
+        return Equals((TimeOnlyDto)obj);
+    }
+    public override int GetHashCode() => Time.GetHashCode();
+}
+
+public class NullableDateOnlyDto
+{
+    public DateOnly? Date { get; set; }
+
+    protected bool Equals(NullableDateOnlyDto other) => Date.Equals(other.Date);
+    public override bool Equals(object obj)
+    {
+        if (ReferenceEquals(null, obj)) return false;
+        if (ReferenceEquals(this, obj)) return true;
+        if (obj.GetType() != this.GetType()) return false;
+        return Equals((NullableDateOnlyDto)obj);
+    }
+    public override int GetHashCode() => (Date ?? default).GetHashCode();
+}
+
+public class NullableTimeOnlyDto
+{
+    public TimeOnly? Time { get; set; }
+
+    protected bool Equals(NullableTimeOnlyDto other) => Time.Equals(other.Time);
+    public override bool Equals(object obj)
+    {
+        if (ReferenceEquals(null, obj)) return false;
+        if (ReferenceEquals(this, obj)) return true;
+        if (obj.GetType() != this.GetType()) return false;
+        return Equals((NullableTimeOnlyDto)obj);
+    }
+    public override int GetHashCode() => (Time ?? default).GetHashCode();
+}
+
+public class Net6TypeTests
+{
+    [Test]
+    public void Can_serialize_DateOnly()
+    {
+        var date = new DateOnly(2001, 1, 13);
+        var json = date.ToJson();
+        Assert.That(json, Is.EqualTo("\"2001-01-13\""));
+
+        var fromJson = json.FromJson<DateOnly>();
+        Assert.That(fromJson, Is.EqualTo(date));
+        
+        var dto = new DateOnlyDto { Date = date };
+        json = dto.ToJson();
+        Assert.That(json, Is.EqualTo("{\"Date\":\"2001-01-13\"}"));
+        var fromJsonDto = json.FromJson<DateOnlyDto>();
+        Assert.That(fromJsonDto, Is.EqualTo(dto));
+
+        var nullableDto = new NullableDateOnlyDto { Date = date };
+        json = nullableDto.ToJson();
+        Assert.That(json, Is.EqualTo("{\"Date\":\"2001-01-13\"}"));
+        var fromJsonNullableDto = json.FromJson<NullableDateOnlyDto>();
+        Assert.That(fromJsonNullableDto, Is.EqualTo(nullableDto));
+    }
+
+    [Test]
+    public void Can_serialize_DateOnly_UnixTime()
+    {
+        using (JsConfig.With(new Config { DateHandler = DateHandler.UnixTime }))
+        {
+            var date = new DateOnly(2001, 1, 13);
+            var json = date.ToJson();
+            Assert.That(json, Is.EqualTo("979344000"));
+
+            var fromJson = json.FromJson<DateOnly>();
+            Assert.That(fromJson, Is.EqualTo(date));
+
+            var dto = new DateOnlyDto { Date = date };
+            json = dto.ToJson();
+            Assert.That(json, Is.EqualTo("{\"Date\":979344000}"));
+
+            var nullableDto = new NullableDateOnlyDto { Date = date };
+            json = nullableDto.ToJson();
+            Assert.That(json, Is.EqualTo("{\"Date\":979344000}"));
+        }
+    }
+    
+    [Test]
+    public void Can_serialize_TimeOnly()
+    {
+        var time = new TimeOnly(13, 13, 13);
+        var json = time.ToJson();
+        Assert.That(json, Is.EqualTo("\"PT13H13M13S\""));
+
+        var fromJson = json.FromJson<TimeOnly>();
+        Assert.That(fromJson, Is.EqualTo(time));
+        
+        var dto = new TimeOnlyDto { Time = time };
+        json = dto.ToJson();
+        Assert.That(json, Is.EqualTo("{\"Time\":\"PT13H13M13S\"}"));
+        var fromJsonDto = json.FromJson<TimeOnlyDto>();
+        Assert.That(fromJsonDto, Is.EqualTo(dto));
+
+        var nullableDto = new NullableTimeOnlyDto { Time = time };
+        json = nullableDto.ToJson();
+        Assert.That(json, Is.EqualTo("{\"Time\":\"PT13H13M13S\"}"));
+        var fromJsonNullableDto = json.FromJson<NullableTimeOnlyDto>();
+        Assert.That(fromJsonNullableDto, Is.EqualTo(nullableDto));
+    }
+
+}
+#endif
diff --git a/tests/ServiceStack.Text.Tests/ServiceStack.Text.Tests.csproj b/tests/ServiceStack.Text.Tests/ServiceStack.Text.Tests.csproj
@@ -23,9 +23,9 @@
     <ProjectReference Include="..\Northwind.Common\Northwind.Common.csproj" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="NUnit3TestAdapter" Version="3.10.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.8.0" />
-    <PackageReference Include="NUnit" Version="3.10.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
+    <PackageReference Include="NUnit" Version="3.13.2" />
     <PackageReference Include="protobuf-net" Version="3.0.101" />
     <PackageReference Include="System.ComponentModel.TypeConverter" Version="4.3.0" />
     <PackageReference Include="System.Drawing.Primitives" Version="4.3.0" />
diff --git a/tests/ServiceStack.Text.TestsConsole/ServiceStack.Text.TestsConsole.csproj b/tests/ServiceStack.Text.TestsConsole/ServiceStack.Text.TestsConsole.csproj
@@ -1,7 +1,7 @@
 ﻿<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
   </PropertyGroup>
   <ItemGroup>
 <!--    <PackageReference Include="NUnit3TestAdapter" Version="3.10.0" />-->

Original file line number	Diff line number	Diff line change
`@@ -76,6 +76,11 @@ public static long ToUnixTimeMs(this long ticks)`
`76`	`76`	`return (ticks - UnixEpoch) / TimeSpan.TicksPerMillisecond;`
`77`	`77`	`}`
`78`	`78`
	`79`	`+#if NET6_0`
	`80`	`+ public static long ToUnixTimeMs(this DateOnly dateOnly) => dateOnly.ToDateTime(default, DateTimeKind.Utc).ToUnixTimeMs();`
	`81`	`+ public static long ToUnixTime(this DateOnly dateOnly) => dateOnly.ToDateTime(default, DateTimeKind.Utc).ToUnixTime();`
	`82`	`+#endif`
	`83`	`+`
`79`	`84`	`public static DateTime FromUnixTimeMs(this double msSince1970)`
`80`	`85`	`{`
`81`	`86`	`return UnixEpochDateTimeUtc + TimeSpan.FromMilliseconds(msSince1970);`