Fixes #2293: Enable DateOnly and TimeOnly

src/Microsoft.OData.Client/Serialization/PrimitiveType.cs

@@ -8,6 +8,7 @@ namespace Microsoft.OData.Client
 {
     using System;
     using System.Collections.Generic;
+    using System.ComponentModel;
     using System.Diagnostics;
     using System.Linq;
 
@@ -367,7 +368,10 @@ private static void InitializeTypes()
             RegisterKnownType(typeof(GeometryMultiPolygon), XmlConstants.EdmGeometryMultiPolygonTypeName, EdmPrimitiveTypeKind.GeometryMultiPolygon, new GeometryTypeConverter(), true);
             RegisterKnownType(typeof(DataServiceStreamLink), XmlConstants.EdmStreamTypeName, EdmPrimitiveTypeKind.Stream, new NamedStreamTypeConverter(), false);
             RegisterKnownType(typeof(Date), XmlConstants.EdmDateTypeName, EdmPrimitiveTypeKind.Date, new DateTypeConverter(), true);
-            RegisterKnownType(typeof(TimeOfDay), XmlConstants.EdmTimeOfDayTypeName, EdmPrimitiveTypeKind.TimeOfDay, new TimeOfDayConvert(), true);
+            RegisterKnownType(typeof(TimeOfDay), XmlConstants.EdmTimeOfDayTypeName, EdmPrimitiveTypeKind.TimeOfDay, new TimeOfDayConverter(), true);
+
+            RegisterKnownType(typeof(DateOnly), XmlConstants.EdmDateTypeName, EdmPrimitiveTypeKind.Date, new DateOnlyTypeConverter(), true);
+            RegisterKnownType(typeof(TimeOnly), XmlConstants.EdmTimeOfDayTypeName, EdmPrimitiveTypeKind.TimeOfDay, new TimeOnlyConverter(), true);
 
             // Following are known types are mapped to existing Edm type
             RegisterKnownType(typeof(Char), XmlConstants.EdmStringTypeName, EdmPrimitiveTypeKind.String, new CharTypeConverter(), false);

src/Microsoft.OData.Client/Serialization/PrimitiveXmlConverter.cs

@@ -858,10 +858,36 @@ internal override string ToString(object instance)
         }
     }
 
+    /// <summary>
+    /// Convert between primitive types Edm.Date and string
+    /// </summary>
+    internal sealed class DateOnlyTypeConverter : PrimitiveTypeConverter
+    {
+        /// <summary>
+        /// Create an instance of primitive type from a string representation
+        /// </summary>
+        /// <param name="text">The string representation</param>
+        /// <returns>An instance of primitive type</returns>
+        internal override object Parse(string text)
+        {
+            return PlatformHelper.ConvertStringToDateOnly(text);
+        }
+
+        /// <summary>
+        /// Convert an instance of primitive type to string
+        /// </summary>
+        /// <param name="instance">The instance</param>
+        /// <returns>The string representation of the instance</returns>
+        internal override string ToString(object instance)
+        {
+            return ((Date)(DateOnly)instance).ToString();
+        }
+    }
+
     /// <summary>
     /// Convert between primitive types Edm.TimeOfDay and string
     /// </summary>
-    internal sealed class TimeOfDayConvert : PrimitiveTypeConverter
+    internal sealed class TimeOfDayConverter : PrimitiveTypeConverter
     {
         /// <summary>
         /// Create an instance of primitive type from a string representation
@@ -883,4 +909,30 @@ internal override string ToString(object instance)
             return ((TimeOfDay)instance).ToString();
         }
     }
+
+    /// <summary>
+    /// Convert between primitive types Edm.TimeOfDay and string
+    /// </summary>
+    internal sealed class TimeOnlyConverter : PrimitiveTypeConverter
+    {
+        /// <summary>
+        /// Create an instance of primitive type from a string representation
+        /// </summary>
+        /// <param name="text">The string representation</param>
+        /// <returns>An instance of primitive type</returns>
+        internal override object Parse(string text)
+        {
+            return PlatformHelper.ConvertStringToTimeOnly(text);
+        }
+
+        /// <summary>
+        /// Convert an instance of primitive type to string
+        /// </summary>
+        /// <param name="instance">The instance</param>
+        /// <returns>The string representation of the instance</returns>
+        internal override string ToString(object instance)
+        {
+            return ((TimeOfDay)(TimeOnly)instance).ToString();
+        }
+    }
 }

src/Microsoft.OData.Core/Evaluation/EdmValueUtils.cs

@@ -283,6 +283,12 @@ private static IEdmDelayedValue ConvertPrimitiveValueWithoutTypeCode(object prim
                 return new EdmDateConstant(dateType, (Date)primitiveValue);
             }
 
+            if (primitiveValue is DateOnly dateOnly)
+            {
+                IEdmPrimitiveTypeReference dateType = EnsurePrimitiveType(type, EdmPrimitiveTypeKind.Date);
+                return new EdmDateConstant(dateType, dateOnly);
+            }
+
             if (primitiveValue is DateTimeOffset)
             {
                 IEdmTemporalTypeReference dateTimeOffsetType = (IEdmTemporalTypeReference)EnsurePrimitiveType(type, EdmPrimitiveTypeKind.DateTimeOffset);
@@ -301,6 +307,12 @@ private static IEdmDelayedValue ConvertPrimitiveValueWithoutTypeCode(object prim
                 return new EdmTimeOfDayConstant(timeOfDayType, (TimeOfDay)primitiveValue);
             }
 
+            if (primitiveValue is TimeOnly timeOnly)
+            {
+                IEdmTemporalTypeReference timeOfDayType = (IEdmTemporalTypeReference)EnsurePrimitiveType(type, EdmPrimitiveTypeKind.TimeOfDay);
+                return new EdmTimeOfDayConstant(timeOfDayType, timeOnly);
+            }
+
             if (primitiveValue is TimeSpan)
             {
                 IEdmTemporalTypeReference timeType = (IEdmTemporalTypeReference)EnsurePrimitiveType(type, EdmPrimitiveTypeKind.Duration);

src/Microsoft.OData.Core/Evaluation/LiteralFormatter.cs

@@ -27,12 +27,14 @@ namespace Microsoft.OData.Evaluation
 #if ODATA_CORE
     using Microsoft.OData.Edm;
     using Microsoft.Spatial;
+    using System.Globalization;
 #else
     using System.Xml.Linq;
     using Microsoft.OData;
     using Microsoft.OData.Edm;
     using Microsoft.Spatial;
     using ExpressionConstants = XmlConstants;
+    using System.Globalization;
 #endif
 
     /// <summary>
@@ -223,6 +225,11 @@ private static string FormatRawLiteral(object value)
                 return value.ToString();
             }
 
+            if (value is DateOnly dateOnly)
+            {
+                return ((Date)dateOnly).ToString();
+            }
+
             if (value is DateTimeOffset)
             {
                 return XmlConvert.ToString((DateTimeOffset)value);
@@ -233,6 +240,11 @@ private static string FormatRawLiteral(object value)
                 return value.ToString();
             }
 
+            if (value is TimeOnly timeOnly)
+            {
+                return ((TimeOfDay)timeOnly).ToString();
+            }
+
             if (value is TimeSpan)
             {
                 return EdmValueWriter.DurationAsXml((TimeSpan)value);

src/Microsoft.OData.Core/Json/JsonWriterExtensions.Async.cs

@@ -135,11 +135,21 @@ internal static Task WritePrimitiveValueAsync(this IJsonWriter jsonWriter, objec
                 return jsonWriter.WriteValueAsync((Date)value);
             }
 
+            if (value is DateOnly dateOnly)
+            {
+                return jsonWriter.WriteValueAsync(dateOnly); // will implicitly to call 'Date' version
+            }
+
             if (value is TimeOfDay)
             {
                 return jsonWriter.WriteValueAsync((TimeOfDay)value);
             }
 
+            if (value is TimeOnly timeOnly)
+            {
+                return jsonWriter.WriteValueAsync(timeOnly); // will implicitly to call 'TimeOfDay' version
+            }
+
             return TaskUtils.GetFaultedTask(
                 new ODataException(ODataErrorStrings.ODataJsonWriter_UnsupportedValueType(value.GetType().FullName)));
         }

src/Microsoft.OData.Core/Json/JsonWriterExtensions.cs

@@ -147,12 +147,27 @@ internal static void WritePrimitiveValue(this IJsonWriter jsonWriter, object val
                 return;
             }
 
+            // Why don't merge 'DateOnly' into 'Date' if clause?
+            // Because 'value' is System.Object, it's a boxed of 'DateOnly' and will throw exception to cast it to 'Date'.
+            // It's same for TimeOnly
+            if (value is DateOnly dateOnly)
+            {
+                jsonWriter.WriteValue(dateOnly);
+                return;
+            }
+
             if (value is TimeOfDay)
             {
                 jsonWriter.WriteValue((TimeOfDay)value);
                 return;
             }
 
+            if (value is TimeOnly timeOnly)
+            {
+                jsonWriter.WriteValue(timeOnly);
+                return;
+            }
+
             throw new ODataException(ODataErrorStrings.ODataJsonWriter_UnsupportedValueType(value.GetType().FullName));
         }
 

src/Microsoft.OData.Core/Json/ODataJsonWriterUtils.cs

@@ -121,7 +121,9 @@ internal static void ODataValueToString(StringBuilder sb, ODataValue value)
                         valueAsString = JsonValueUtils.GetEscapedJsonString(valueAsString);
                         sb.Append('"').Append(valueAsString).Append('"');
                     }
-                    else if (valueAsObject is byte[] || valueAsObject is DateTimeOffset || valueAsObject is Guid || valueAsObject is TimeSpan | valueAsObject is Date || valueAsObject is TimeOfDay)
+                    else if (valueAsObject is byte[] || valueAsObject is DateTimeOffset || valueAsObject is Guid
+                        || valueAsObject is TimeSpan || valueAsObject is Date || valueAsObject is TimeOfDay
+                        || valueAsObject is DateOnly || valueAsObject is TimeOnly)
                     {
                         sb.Append('"').Append(valueAsString).Append('"');
                     }

src/Microsoft.OData.Core/Metadata/EdmLibraryExtensions.cs

@@ -140,6 +140,11 @@ static EdmLibraryExtensions()
             PrimitiveTypeReferenceMap.Add(typeof(TimeOfDay), ToTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.TimeOfDay), false));
             PrimitiveTypeReferenceMap.Add(typeof(TimeOfDay?), ToTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.TimeOfDay), true));
 
+            PrimitiveTypeReferenceMap.Add(typeof(DateOnly), ToTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Date), false));
+            PrimitiveTypeReferenceMap.Add(typeof(DateOnly?), ToTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Date), true));
+            PrimitiveTypeReferenceMap.Add(typeof(TimeOnly), ToTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.TimeOfDay), false));
+            PrimitiveTypeReferenceMap.Add(typeof(TimeOnly?), ToTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.TimeOfDay), true));
+
 #if !NETSTANDARD1_1
             // Pack type codes of supported primitive types in the bitmap
             // See the type codes here: https://learn.microsoft.com/en-us/dotnet/api/system.typecode

src/Microsoft.OData.Core/ODataPayloadValueConverter.cs

@@ -174,6 +174,18 @@ private static object ConvertStringValue(string stringValue, Type targetType)
                 return PlatformHelper.ConvertStringToTimeOfDay(stringValue);
             }
 
+            // DateOnly
+            if (targetType == typeof(DateOnly))
+            {
+                return PlatformHelper.ConvertStringToDateOnly(stringValue);
+            }
+
+            // TimeOnly
+            if (targetType == typeof(TimeOnly))
+            {
+                return PlatformHelper.ConvertStringToTimeOnly(stringValue);
+            }
+
             // DateTimeOffset needs to be read using the XML rules (as per the Json spec).
             if (targetType == typeof(DateTimeOffset))
             {

src/Microsoft.OData.Core/ODataRawValueUtils.cs

@@ -123,13 +123,25 @@ internal static bool TryConvertPrimitiveToString(object value, out string result
                 return true;
             }
 
+            if ( value is DateOnly dateOnly)
+            {
+                result = ODataRawValueConverter.ToString(dateOnly);
+                return true;
+            }
+
             if (value is TimeOfDay)
             {
                 // Edm.TimeOfDay
                 result = ODataRawValueConverter.ToString((TimeOfDay)value);
                 return true;
             }
 
+            if (value is TimeOnly timeOnly)
+            {
+                result = ODataRawValueConverter.ToString(timeOnly);
+                return true;
+            }
+
             result = null;
             return false;
         }

src/Microsoft.OData.Core/Uri/ODataUriConversionUtils.cs

@@ -512,6 +512,12 @@ internal static object CoerceTemporalType(object primitiveValue, IEdmPrimitiveTy
                         return new DateTimeOffset(dateValue.Year, dateValue.Month, dateValue.Day, 0, 0, 0, new TimeSpan(0));
                     }
 
+                    if (primitiveValue is DateOnly dateOnly)
+                    {
+                        var dateValue = (Date)dateOnly;
+                        return new DateTimeOffset(dateValue.Year, dateValue.Month, dateValue.Day, 0, 0, 0, new TimeSpan(0));
+                    }
+
                     break;
 
                 case EdmPrimitiveTypeKind.Date:

src/Microsoft.OData.Edm/PublicAPI/net8.0/PublicAPI.Unshipped.txt

@@ -1 +1,4 @@
-
+static Microsoft.OData.Edm.Date.implicit operator Microsoft.OData.Edm.Date(System.DateOnly operand) -> Microsoft.OData.Edm.Date
+static Microsoft.OData.Edm.Date.implicit operator System.DateOnly(Microsoft.OData.Edm.Date operand) -> System.DateOnly
+static Microsoft.OData.Edm.TimeOfDay.implicit operator Microsoft.OData.Edm.TimeOfDay(System.TimeOnly timeOnly) -> Microsoft.OData.Edm.TimeOfDay
+static Microsoft.OData.Edm.TimeOfDay.implicit operator System.TimeOnly(Microsoft.OData.Edm.TimeOfDay time) -> System.TimeOnly

src/Microsoft.OData.Edm/Schema/Date.cs

@@ -230,6 +230,26 @@ public static implicit operator Date(DateTime operand)
             return new Date(operand.Year, operand.Month, operand.Day);
         }
 
+        /// <summary>
+        /// Convert Date to Clr DateOnly
+        /// </summary>
+        /// <param name="operand">Date Value</param>
+        /// <returns>DateTime Value which represent the Date</returns>
+        public static implicit operator DateOnly(Date operand)
+        {
+            return DateOnly.FromDateTime(operand.dateTime);
+        }
+
+        /// <summary>
+        /// Convert Clr DateOnly to Date
+        /// </summary>
+        /// <param name="operand">DateOnly Value</param>
+        /// <returns>Date Value from DateOnly</returns>
+        public static implicit operator Date(DateOnly operand)
+        {
+            return new Date(operand.Year, operand.Month, operand.Day);
+        }
+
         /// <summary>
         /// Convert Date to String
         /// </summary>

src/Microsoft.OData.Edm/Schema/TimeOfDay.cs

@@ -253,6 +253,26 @@ public static implicit operator TimeOfDay(TimeSpan timeSpan)
             }
         }
 
+        /// <summary>
+        /// Convert TimeOfDay to .Net TimeOnly
+        /// </summary>
+        /// <param name="time">TimeOfDay Value</param>
+        /// <returns>TimeOnly Value which represent the TimeOfDay</returns>
+        public static implicit operator TimeOnly(TimeOfDay time)
+        {
+            return TimeOnly.FromTimeSpan(time.timeSpan);
+        }
+
+        /// <summary>
+        /// Convert .Net Clr TimeOnly to TimeOfDay
+        /// </summary>
+        /// <param name="timeOnly">TimeOnly Value</param>
+        /// <returns>TimeOfDay Value from TimeOnly</returns>
+        public static implicit operator TimeOfDay(TimeOnly timeOnly)
+        {
+            return new TimeOfDay(timeOnly.Ticks);
+        }
+
         /// <summary>
         /// Compares the value of this instance to a specified TimeOfDay value
         /// and returns an bool that indicates whether this instance is same as the specified TimeOfDay value.

src/PlatformHelper.cs

@@ -235,6 +235,22 @@ internal static Date ConvertStringToDate(string text)
             return date;
         }
 
+        /// <summary>
+        /// Converts a string to a DateOnly.
+        /// </summary>
+        /// <param name="text">String to be converted.</param>
+        /// <returns>DateOnly value</returns>
+        internal static DateOnly ConvertStringToDateOnly(string text)
+        {
+            DateOnly date;
+            if (!DateOnly.TryParse(text, out date))
+            {
+                throw new FormatException(string.Format(CultureInfo.InvariantCulture, "String '{0}' was not recognized as a valid Edm.Date.", text));
+            }
+
+            return date;
+        }
+
         /// <summary>
         /// Converts a string to a TimeOfDay.
         /// </summary>
@@ -267,6 +283,22 @@ internal static TimeOfDay ConvertStringToTimeOfDay(string text)
 
             return timeOfDay;
         }
+
+        /// <summary>
+        /// Converts a string to a TimeOnly.
+        /// </summary>
+        /// <param name="text">String to be converted.</param>
+        /// <returns>TimeOnly value</returns>
+        internal static TimeOnly ConvertStringToTimeOnly(string text)
+        {
+            TimeOnly timeOfDay;
+            if (!TimeOnly.TryParse(text, out timeOfDay))
+            {
+                throw new FormatException(string.Format(CultureInfo.InvariantCulture, "String '{0}' was not recognized as a valid Edm.TimeOfDay.", text));
+            }
+
+            return timeOfDay;
+        }
 #endif
 
         /// <summary>