OData · gathogojr · May 19, 2025
diff --git a/src/Microsoft.OData.Core/Evaluation/EdmValueUtils.cs b/src/Microsoft.OData.Core/Evaluation/EdmValueUtils.cs
@@ -8,10 +8,11 @@
 using System.Diagnostics;
 using Microsoft.OData.Edm;
 using Microsoft.OData.Edm.Vocabularies;
-using Microsoft.Spatial;
 using Microsoft.OData.Core;
+using Microsoft.OData.Spatial;
+
 #if ODATA_CLIENT
-    using Microsoft.OData;
+using Microsoft.OData;
 #endif
 
 #if ODATA_CLIENT
@@ -318,7 +319,7 @@ private static IEdmDelayedValue ConvertPrimitiveValueWithoutTypeCode(object prim
                 return new EdmDurationConstant(timeType, (TimeSpan)primitiveValue);
             }
 
-            if (primitiveValue is ISpatial)
+            if (primitiveValue is Geometry || primitiveValue is Geography)
             {
                 // TODO: [Json] Add support for spatial values in ODataEdmStructuredValue
                 throw new NotImplementedException();

diff --git a/src/Microsoft.OData.Core/GeoJsonPrimitiveTypeConverter.cs b/src/Microsoft.OData.Core/GeoJsonPrimitiveTypeConverter.cs
@@ -0,0 +1,28 @@
+//---------------------------------------------------------------------
+// <copyright file="GeoJsonPrimitiveTypeConverter.cs" company="Microsoft">
+//      Copyright (C) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+// </copyright>
+//---------------------------------------------------------------------
+
+namespace Microsoft.OData
+{
+    #region Namespaces
+    using System.Threading.Tasks;
+    using Microsoft.OData.Json;
+
+    #endregion
+
+    internal class GeoJsonPrimitiveTypeConverter : SpatialPrimitiveTypeConverter, ISpatialPrimitiveTypeConverter
+    {
+        protected override void WriteCrs(IJsonWriter jsonWriter, int srid)
+        {
+            // No-op - to conform with GeoJSON spec, we don't write CRS in this implementation.
+        }
+
+        protected override Task WriteCrsAsync(IJsonWriter jsonWriter, int srid)
+        {
+            // No-op - to conform with GeoJSON spec, we don't write CRS in this implementation.
+            return Task.CompletedTask;
+        }
+    }
+}
diff --git a/src/Microsoft.OData.Core/GeoJsonSpatialObjectFormatter.cs b/src/Microsoft.OData.Core/GeoJsonSpatialObjectFormatter.cs
diff --git a/src/Microsoft.OData.Core/GeographyTypeConverter.cs b/src/Microsoft.OData.Core/GeographyTypeConverter.cs
@@ -4,6 +4,8 @@
 // </copyright>
 //---------------------------------------------------------------------
 
+using System;
+using System.Threading.Tasks;
 using Microsoft.OData.Json;
 using Microsoft.Spatial;
 
@@ -24,5 +26,20 @@ public void WriteJson(object instance, IJsonWriter jsonWriter)
             IGeoJsonWriter adapter = new GeoJsonWriterAdapter(jsonWriter);
             ((Geography)instance).SendTo(GeoJsonObjectFormatter.Create().CreateWriter(adapter));
         }
+
+        /// <summary>
+        /// Asynchronously writes the JSON representation of an instance of a primitive type to a json writer.
+        /// </summary>
+        /// <param name="instance">The instance to write.</param>
+        /// <param name="jsonWriter">Instance of JsonWriter.</param>
+        /// <returns>A task that represents the asynchronous write operation.</returns>
+        public Task WriteJsonAsync(object instance, IJsonWriter jsonWriter)
+        {
+            return TaskUtils.GetTaskForSynchronousOperation(
+                (thisParam, instanceParam, jsonWriterParam) => thisParam.WriteJson(instanceParam, jsonWriterParam),
+                this,
+                instance,
+                jsonWriter);
+        }
     }
 }
diff --git a/src/Microsoft.OData.Core/GeometryTypeConverter.cs b/src/Microsoft.OData.Core/GeometryTypeConverter.cs
@@ -4,6 +4,8 @@
 // </copyright>
 //---------------------------------------------------------------------
 
+using System;
+using System.Threading.Tasks;
 using Microsoft.OData.Json;
 using Microsoft.Spatial;
 
@@ -28,5 +30,20 @@ public void WriteJson(object instance, IJsonWriter jsonWriter)
             IGeoJsonWriter adapter = new GeoJsonWriterAdapter(jsonWriter);
             ((Geometry)instance).SendTo(GeoJsonObjectFormatter.Create().CreateWriter(adapter));
         }
+
+        /// <summary>
+        /// Asynchronously writes the JSON representation of an instance of a primitive type to a json writer.
+        /// </summary>
+        /// <param name="instance">The instance to write.</param>
+        /// <param name="jsonWriter">Instance of JsonWriter.</param>
+        /// <returns>A task that represents the asynchronous write operation.</returns>
+        public Task WriteJsonAsync(object instance, IJsonWriter jsonWriter)
+        {
+            return TaskUtils.GetTaskForSynchronousOperation(
+                (thisParam, instanceParam, jsonWriterParam) => thisParam.WriteJson(instanceParam, jsonWriterParam),
+                this,
+                instance,
+                jsonWriter);
+        }
     }
 }
diff --git a/src/Microsoft.OData.Core/IPrimitiveTypeConverter.cs b/src/Microsoft.OData.Core/IPrimitiveTypeConverter.cs
@@ -6,20 +6,31 @@
 
 namespace Microsoft.OData
 {
+    using System;
     #region Namespaces
+    using System.Threading.Tasks;
     using Microsoft.OData.Json;
     #endregion
 
     /// <summary>
     /// Interface used for serialization and deserialization of primitive types.
     /// </summary>
-    internal interface IPrimitiveTypeConverter
+    [CLSCompliant(false)]
+    public interface IPrimitiveTypeConverter
     {
         /// <summary>
         /// Write the Json representation of an instance of a primitive type to a json writer.
         /// </summary>
         /// <param name="instance">The instance to write.</param>
         /// <param name="jsonWriter">Instance of JsonWriter.</param>
         void WriteJson(object instance, IJsonWriter jsonWriter);
+
+        /// <summary>
+        /// Asynchronously writes the JSON representation of an instance of a primitive type to a json writer.
+        /// </summary>
+        /// <param name="instance">The instance to write.</param>
+        /// <param name="jsonWriter">Instance of JsonWriter.</param>
+        /// <returns>A task that represents the asynchronous write operation.</returns>
+        Task WriteJsonAsync(object instance, IJsonWriter jsonWriter);
     }
 }
diff --git a/src/Microsoft.OData.Core/ISpatialPrimitiveTypeConverter.cs b/src/Microsoft.OData.Core/ISpatialPrimitiveTypeConverter.cs
@@ -0,0 +1,20 @@
+//---------------------------------------------------------------------
+// <copyright file="ISpatialPrimitiveTypeConverter.cs" company="Microsoft">
+//      Copyright (C) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+// </copyright>
+//---------------------------------------------------------------------
+
+namespace Microsoft.OData
+{
+    #region Namespaces
+    using System.Threading.Tasks;
+    using Microsoft.OData.Json;
+    #endregion
+
+    /// <summary>
+    /// Marker interface to enable targeted registration, resolution, or swapping of spatial converters.
+    /// </summary>
+    public interface ISpatialPrimitiveTypeConverter : IPrimitiveTypeConverter
+    {
+    }
+}
diff --git a/src/Microsoft.OData.Core/Json/JsonMinimalMetadataTypeNameOracle.cs b/src/Microsoft.OData.Core/Json/JsonMinimalMetadataTypeNameOracle.cs
@@ -156,6 +156,7 @@ internal override string GetValueTypeNameForWriting(
                 fullTypeNameFromValue = valueType.FullName;
 
                 // Write type name when the type in the payload is more derived than the type from metadata.
+                // TODO: This check does not check IsAssignableFrom to determine if the type is more derived.
                 if (modelType.TypeReference != null && modelType.FullName != fullTypeNameFromValue)
                 {
                     return fullTypeNameFromValue;

diff --git a/src/Microsoft.OData.Core/Json/ODataJsonReaderCoreUtils.cs b/src/Microsoft.OData.Core/Json/ODataJsonReaderCoreUtils.cs
@@ -10,10 +10,22 @@ namespace Microsoft.OData.Json
     using System;
     using System.Collections.Generic;
     using System.Diagnostics;
-    using Microsoft.Spatial;
-    using Microsoft.OData.Edm;
-    using Microsoft.OData.Core;
+    using System.Diagnostics.Contracts;
+    using System.Text;
+    using System.Text.Json.Nodes;
     using System.Threading.Tasks;
+    using Microsoft.OData.Core;
+    using Microsoft.OData.Edm;
+    using Microsoft.OData.Spatial;
+    using NetTopologySuite.IO;
+    using NtsGeometry = NetTopologySuite.Geometries.Geometry;
+    using NtsGeometryCollection = NetTopologySuite.Geometries.GeometryCollection;
+    using NtsLineString = NetTopologySuite.Geometries.LineString;
+    using NtsMultiLineString = NetTopologySuite.Geometries.MultiLineString;
+    using NtsMultiPoint = NetTopologySuite.Geometries.MultiPoint;
+    using NtsMultiPolygon = NetTopologySuite.Geometries.MultiPolygon;
+    using NtsPoint = NetTopologySuite.Geometries.Point;
+    using NtsPolygon = NetTopologySuite.Geometries.Polygon;
 
     #endregion Namespaces
 
@@ -34,7 +46,7 @@ internal static class ODataJsonReaderCoreUtils
         /// <param name="recursionDepth">The recursion depth to start with.</param>
         /// <param name="propertyName">The name of the property whose value is being read, if applicable (used for error reporting).</param>
         /// <returns>An instance of the spatial type.</returns>
-        internal static ISpatial ReadSpatialValue(
+        internal static object ReadSpatialValue(
             IJsonReader jsonReader,
             bool insideJsonObjectValue,
             ODataInputContext inputContext,
@@ -55,20 +67,12 @@ internal static ISpatial ReadSpatialValue(
                 return null;
             }
 
-            ISpatial spatialValue = null;
+            object spatialValue = null;
             if (insideJsonObjectValue || jsonReader.NodeType == JsonNodeType.StartObject)
             {
                 IDictionary<string, object> jsonObject = ReadObjectValue(jsonReader, insideJsonObjectValue, inputContext, recursionDepth);
-                GeoJsonObjectFormatter jsonObjectFormatter =
-                    SpatialImplementation.CurrentImplementation.CreateGeoJsonObjectFormatter();
-                if (expectedValueTypeReference.IsGeography())
-                {
-                    spatialValue = jsonObjectFormatter.Read<Geography>(jsonObject);
-                }
-                else
-                {
-                    spatialValue = jsonObjectFormatter.Read<Geometry>(jsonObject);
-                }
+
+                spatialValue = ParseSpatialValue(expectedValueTypeReference, propertyName, jsonObject);
             }
 
             if (spatialValue == null)
@@ -132,7 +136,7 @@ internal static bool TryReadNullValue(
         /// <param name="recursionDepth">The recursion depth to start with.</param>
         /// <param name="propertyName">The name of the property whose value is being read, if applicable (used for error reporting).</param>
         /// <returns>An instance of the spatial type.</returns>
-        internal static async Task<ISpatial> ReadSpatialValueAsync(
+        internal static async Task<object> ReadSpatialValueAsync(
             IJsonReader jsonReader,
             bool insideJsonObjectValue,
             ODataInputContext inputContext,
@@ -155,21 +159,13 @@ internal static async Task<ISpatial> ReadSpatialValueAsync(
                 return null;
             }
 
-            ISpatial spatialValue = null;
+            object spatialValue = null;
             if (insideJsonObjectValue || jsonReader.NodeType == JsonNodeType.StartObject)
             {
                 Dictionary<string, object> jsonObject = await ReadObjectValueAsync(jsonReader, insideJsonObjectValue, inputContext, recursionDepth)
                     .ConfigureAwait(false);
-                GeoJsonObjectFormatter jsonObjectFormatter =
-                    SpatialImplementation.CurrentImplementation.CreateGeoJsonObjectFormatter();
-                if (expectedValueTypeReference.IsGeography())
-                {
-                    spatialValue = jsonObjectFormatter.Read<Geography>(jsonObject);
-                }
-                else
-                {
-                    spatialValue = jsonObjectFormatter.Read<Geometry>(jsonObject);
-                }
+
+                spatialValue = ParseSpatialValue(expectedValueTypeReference, propertyName, jsonObject);
             }
 
             if (spatialValue == null)
@@ -178,7 +174,7 @@ internal static async Task<ISpatial> ReadSpatialValueAsync(
             }
 
             return spatialValue;
-        }
+        }        
 
         /// <summary>
         /// Asynchronously tries to read a null value from the JSON reader.
@@ -442,5 +438,56 @@ await jsonReader.ReadEndArrayAsync()
 
             return items;
         }
+
+        private static object ParseSpatialValue(
+            IEdmPrimitiveTypeReference expectedValueTypeReference,
+            string propertyName,
+            IDictionary<string, object> spatialDict)
+        {
+            Contract.Assert(expectedValueTypeReference.IsGeography() || expectedValueTypeReference.IsGeometry());
+
+            NtsGeometry ntsGeometry = GeoJsonSpatialObjectFormatter.ParseGeometry(propertyName, spatialDict);
+
+            if (ntsGeometry == null)
+            {
+                Debug.Assert(false, "Parsed geometry is null.");
+                return null;
+            }
+
+            // Map NTS type to OData spatial type
+            return expectedValueTypeReference.IsGeography()
+                ? CreateGeography(ntsGeometry)
+                : CreateGeometry(ntsGeometry);
+        }
+
+        private static object CreateGeography(NtsGeometry ntsGeometry)
+        {
+            return ntsGeometry switch
+            {
+                NtsPoint point => new GeographyPoint(point),
+                NtsLineString lineString => new GeographyLineString(lineString),
+                NtsPolygon polygon => new GeographyPolygon(polygon),
+                NtsMultiPoint multiPoint => new GeographyMultiPoint(multiPoint),
+                NtsMultiLineString multiLineString => new GeographyMultiLineString(multiLineString),
+                NtsMultiPolygon multiPolygon => new GeographyMultiPolygon(multiPolygon),
+                NtsGeometryCollection geometryCollection => new GeographyCollection(geometryCollection),
+                _ => throw new ODataException(SRResources.ODataJsonReaderCoreUtils_CannotReadSpatialPropertyValue)
+            };
+        }
+
+        private static object CreateGeometry(NtsGeometry ntsGeometry)
+        {
+            return ntsGeometry switch
+            {
+                NtsPoint point => new GeometryPoint(point),
+                NtsLineString lineString => new GeometryLineString(lineString),
+                NtsPolygon polygon => new GeometryPolygon(polygon),
+                NtsMultiPoint multiPoint => new GeometryMultiPoint(multiPoint),
+                NtsMultiLineString multiLineString => new GeometryMultiLineString(multiLineString),
+                NtsMultiPolygon multiPolygon => new GeometryMultiPolygon(multiPolygon),
+                NtsGeometryCollection geometryCollection => new GeometryCollection(geometryCollection),
+                _ => throw new ODataException(SRResources.ODataJsonReaderCoreUtils_CannotReadSpatialPropertyValue)
+            };
+        }
     }
 }
diff --git a/src/Microsoft.OData.Core/Json/ODataJsonValueSerializer.cs b/src/Microsoft.OData.Core/Json/ODataJsonValueSerializer.cs
@@ -688,13 +688,8 @@ public virtual async Task WritePrimitiveValueAsync(
 
             if (actualTypeReference != null && actualTypeReference.IsSpatial())
             {
-                // TODO: Implement asynchronous handling of spatial types in a separate PR
-                await TaskUtils.GetTaskForSynchronousOperation(
-                    (thisParam, valueParam) => PrimitiveConverter.Instance.WriteJson(
-                        valueParam,
-                        thisParam.JsonWriter),
-                    this,
-                    value).ConfigureAwait(false);
+                await PrimitiveConverter.Instance.WriteJsonAsync(value, this.JsonWriter)
+                    .ConfigureAwait(false);
             }
             else
             {

diff --git a/src/Microsoft.OData.Core/Metadata/EdmLibraryExtensions.cs b/src/Microsoft.OData.Core/Metadata/EdmLibraryExtensions.cs
@@ -15,7 +15,6 @@ namespace Microsoft.OData.Metadata
     using System.Globalization;
     using System.IO;
     using System.Linq;
-    using Microsoft.Spatial;
     using Microsoft.OData.Edm;
 #if ODATA_SERVICE
     using Microsoft.OData.Service;
@@ -28,6 +27,7 @@ namespace Microsoft.OData.Metadata
     using Microsoft.OData.Json;
     using Microsoft.OData.UriParser;
     using Microsoft.OData.Core;
+    using Microsoft.OData.Spatial;
 #endif
     #endregion Namespaces
 
@@ -646,7 +646,7 @@ internal static bool IsPrimitiveType(Type clrType)
                 // then it could take longer to reach the types in the last predicates than to look them up in the
                 // dictionary. So for a good balance handle common types directly and the rest in the dictionary.
                 || PrimitiveTypeReferenceMap.ContainsKey(clrType)
-                || typeof(ISpatial).IsAssignableFrom(clrType);
+                || clrType.IsSpatial();
         }
 
         /// <summary>
@@ -1583,6 +1583,10 @@ internal static IEdmPrimitiveTypeReference GetPrimitiveTypeReference(Type clrTyp
             {
                 primitiveType = EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Geometry);
             }
+            else if (typeof(NetTopologySuite.Geometries.Point).IsAssignableFrom(clrType))
+            {
+                primitiveType = EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.GeometryPoint);
+            }
 
             if (primitiveType == null)
             {

diff --git a/src/Microsoft.OData.Core/Microsoft.OData.Core.csproj b/src/Microsoft.OData.Core/Microsoft.OData.Core.csproj
@@ -47,6 +47,8 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="NetTopologySuite" Version="2.6.0" />
+    <PackageReference Include="NetTopologySuite.IO.GeoJSON" Version="4.0.0" />
     <PackageReference Include="System.Buffers" Version="4.5.1" />
   </ItemGroup>