ADT: Fix the issue with non-default object serializers in Query APIs

eng/Packages.Data.props

@@ -153,6 +153,7 @@
     <PackageReference Update="Microsoft.AspNetCore.Server.Kestrel" Version="2.2.0" />
     <PackageReference Update="Microsoft.AspNetCore.Server.WebListener" Version="1.0.2" />
     <PackageReference Update="Microsoft.Azure.Core.Spatial" Version="1.0.0" />
+    <PackageReference Update="Microsoft.Azure.Core.NewtonsoftJson" Version="1.0.0" />
     <PackageReference Update="Microsoft.Azure.Devices" Version="1.19.0" />
     <PackageReference Update="Microsoft.Azure.Devices.Client" Version="1.27.0" />
     <PackageReference Update="Microsoft.Azure.Graph.RBAC" Version="2.2.2-preview" />

sdk/digitaltwins/Azure.DigitalTwins.Core/src/Models/QueryResult.cs

@@ -4,7 +4,6 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Text.Json;
-using Azure.Core;
 using Azure.Core.Serialization;
 
 namespace Azure.DigitalTwins.Core
@@ -26,12 +25,11 @@ internal partial class QueryResult<T>
         internal string ContinuationToken { get; }
 
         /// <summary>
-        /// Initializes a new instance of QueryResult.
+        /// In order to serialize/deserialize JsonElements into and out of a stream, we have to use the out of the box ObjectSerializer (JsonObjectSerializer).
+        /// This static property is instantiated whenever it is used so we can efficiently re-use the same object serializer that is provided by default
+        /// If the user specifies a different type of serializer to instantiate the client, the SDK will instantiate a new JsonObjectSerializer of its own.
         /// </summary>
-        internal QueryResult()
-        {
-            Value = new ChangeTrackingList<T>();
-        }
+        internal static ObjectSerializer defaultObjectSerializer { get; private set; }
 
         /// <summary>
         /// Initializes a new instance of QueryResult.
@@ -54,6 +52,21 @@ internal static QueryResult<T> DeserializeQueryResult(JsonElement element, Objec
         {
             IReadOnlyList<T> items = default;
             string continuationToken = default;
+
+            // If the provided objectSerializer is of type JsonObjectSerializer, we will re-use the same object and set it as the defaultObjectSerializer.
+            if (objectSerializer is JsonObjectSerializer)
+            {
+                defaultObjectSerializer = objectSerializer;
+            }
+            // Otherwise, if the defaultObjectSerializer is null, we will statically instantiate it and re-use it in the future.
+            else
+            {
+                if (defaultObjectSerializer == null)
+                {
+                    defaultObjectSerializer = new JsonObjectSerializer();
+                }
+            }
+
             foreach (JsonProperty property in element.EnumerateObject())
             {
                 if (property.NameEquals("value"))
@@ -62,13 +75,21 @@ internal static QueryResult<T> DeserializeQueryResult(JsonElement element, Objec
                     {
                         continue;
                     }
+
                     var array = new List<T>();
+
                     foreach (JsonElement item in property.Value.EnumerateArray())
                     {
-                        using MemoryStream streamedObject = StreamHelper.WriteToStream(item, objectSerializer, default);
+                        // defaultObjectSerializer of type JsonObjectSerializer needs to be used to serialize the JsonElement into a stream.
+                        // Using any other ObjectSerializer (ex: NewtonsoftJsonObjectSerializer) won't be able to deserialize the JsonElement into
+                        // a MemoryStream correctly.
+                        using MemoryStream streamedObject = StreamHelper.WriteToStream(item, defaultObjectSerializer, default);
+
+                        // To deserialize the stream object into the generic type of T, the provided ObjectSerializer will be used.
                         T obj = (T)objectSerializer.Deserialize(streamedObject, typeof(T), default);
                         array.Add(obj);
                     }
+
                     items = array;
                     continue;
                 }

sdk/digitaltwins/Azure.DigitalTwins.Core/src/StreamHelper.cs

@@ -42,7 +42,6 @@ internal static MemoryStream WriteToStream<T>(T obj, ObjectSerializer objectSeri
             var memoryStream = new MemoryStream();
 
             objectSerializer.Serialize(memoryStream, obj, typeof(T), cancellationToken);
-
             memoryStream.Seek(0, SeekOrigin.Begin);
 
             return memoryStream;

sdk/digitaltwins/Azure.DigitalTwins.Core/tests/Azure.DigitalTwins.Core.Tests.csproj

@@ -6,11 +6,13 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.Azure.Core.NewtonsoftJson"/>
     <PackageReference Include="Microsoft.Extensions.Configuration" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Binder" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Json" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" />
     <PackageReference Include="FluentAssertions" />
+    <PackageReference Update="Newtonsoft.Json" />
   </ItemGroup>
 
   <ItemGroup>

sdk/digitaltwins/Azure.DigitalTwins.Core/tests/NewtonsoftObjectSerializerTests.cs

@@ -0,0 +1,93 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Azure.Core.Serialization;
+using NUnit.Framework;
+
+namespace Azure.DigitalTwins.Core.Tests
+{
+    /// <summary>
+    /// Tests for custom ObjectSerializer.
+    /// </summary>
+    public class NewtonsoftObjectSerializerTests : E2eTestBase
+    {
+        public NewtonsoftObjectSerializerTests(bool isAsync)
+            : base(isAsync)
+        {
+        }
+
+        [Test]
+        public async Task TestNewtonsoftObjectSerializerWithDigitalTwins()
+        {
+            DigitalTwinsClient defaultClient = GetClient();
+
+            string roomTwinId = await GetUniqueTwinIdAsync(defaultClient, TestAssetDefaults.RoomTwinIdPrefix).ConfigureAwait(false);
+            string floorModelId = await GetUniqueModelIdAsync(defaultClient, TestAssetDefaults.FloorModelIdPrefix).ConfigureAwait(false);
+            string roomModelId = await GetUniqueModelIdAsync(defaultClient, TestAssetDefaults.RoomModelIdPrefix).ConfigureAwait(false);
+
+            try
+            {
+                // arrange
+
+                // create room model
+                string roomModel = TestAssetsHelper.GetRoomModelPayload(roomModelId, floorModelId);
+                await CreateAndListModelsAsync(defaultClient, new List<string> { roomModel }).ConfigureAwait(false);
+
+                // act
+
+                // create room twin
+                BasicDigitalTwin roomTwin = TestAssetsHelper.GetRoomTwinPayload(roomModelId);
+                await defaultClient.CreateOrReplaceDigitalTwinAsync<BasicDigitalTwin>(roomTwinId, roomTwin).ConfigureAwait(false);
+
+                // Create a client with NewtonsoftJsonObjectSerializer configured as the serializer.
+                DigitalTwinsClient testClient = GetClient(
+                    new DigitalTwinsClientOptions
+                    {
+                        Serializer = new NewtonsoftJsonObjectSerializer()
+                    });
+
+                // Get digital twin using the simple DigitalTwin model annotated with Newtonsoft attributes
+                SimpleNewtonsoftDtModel getResponse = await testClient.GetDigitalTwinAsync<SimpleNewtonsoftDtModel>(roomTwinId).ConfigureAwait(false);
+
+                Assert.IsNotNull(getResponse.Id, "Digital twin Id should not be null or empty");
+
+                // Query DigitalTwins using the simple DigitalTwin model annotated with Newtonsoft attributes
+                AsyncPageable<SimpleNewtonsoftDtModel> queryResponse = testClient.QueryAsync<SimpleNewtonsoftDtModel>("SELECT * FROM DIGITALTWINS");
+
+                await foreach (SimpleNewtonsoftDtModel twin in queryResponse)
+                {
+                    Assert.IsNotNull(twin.Id, "Digital twin Id should not be null or empty");
+                }
+            }
+            catch (Exception ex)
+            {
+                Assert.Fail($"Failure in executing a step in the test case: {ex.Message}.");
+            }
+            finally
+            {
+                // cleanup
+                try
+                {
+                    // delete twin
+                    if (!string.IsNullOrWhiteSpace(roomTwinId))
+                    {
+                        await defaultClient.DeleteDigitalTwinAsync(roomTwinId).ConfigureAwait(false);
+                    }
+
+                    // delete models
+                    if (!string.IsNullOrWhiteSpace(roomModelId))
+                    {
+                        await defaultClient.DeleteModelAsync(roomModelId).ConfigureAwait(false);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Assert.Fail($"Test clean up failed: {ex.Message}");
+                }
+            }
+        }
+    }
+}