Fix NullReferenceExceptions during serialization

Microsoft.Azure.Cosmos/src/CosmosClientOptions.cs

@@ -512,7 +512,7 @@ internal Protocol ConnectionProtocol
         /// </summary>
         internal CosmosSerializer GetCosmosSerializerWithWrapperOrDefault()
         {
-            if (this.SerializerOptions != null)
+            if (this.SerializerOptions != null && !this.SerializerOptions.IsDefaultSettings())
             {
                 CosmosJsonDotNetSerializer cosmosJsonDotNetSerializer = new CosmosJsonDotNetSerializer(this.SerializerOptions);
                 return new CosmosJsonSerializerWrapper(cosmosJsonDotNetSerializer);

Microsoft.Azure.Cosmos/src/Serializer/CosmosJsonDotNetSerializer.cs

@@ -4,6 +4,8 @@
 
 namespace Microsoft.Azure.Cosmos
 {
+    using System;
+    using System.Diagnostics;
     using System.IO;
     using System.Text;
     using Newtonsoft.Json;
@@ -15,7 +17,7 @@ namespace Microsoft.Azure.Cosmos
     internal sealed class CosmosJsonDotNetSerializer : CosmosSerializer
     {
         private static readonly Encoding DefaultEncoding = new UTF8Encoding(false, true);
-        private readonly JsonSerializer Serializer;
+        private readonly JsonSerializerSettings SerializerSettings;
 
         /// <summary>
         /// Create a serializer that uses the JSON.net serializer
@@ -26,7 +28,7 @@ internal sealed class CosmosJsonDotNetSerializer : CosmosSerializer
         /// </remarks>
         internal CosmosJsonDotNetSerializer()
         {
-            this.Serializer = JsonSerializer.Create();
+            this.SerializerSettings = null;
         }
 
         /// <summary>
@@ -38,6 +40,11 @@ internal CosmosJsonDotNetSerializer()
         /// </remarks>
         internal CosmosJsonDotNetSerializer(CosmosSerializationOptions cosmosSerializerOptions)
         {
+            if (cosmosSerializerOptions == null || cosmosSerializerOptions.IsDefaultSettings())
+            {
+                throw new ArgumentException("No need to create a custom serializer. The settings are the default.");
+            }
+
             JsonSerializerSettings jsonSerializerSettings = new JsonSerializerSettings()
             {
                 NullValueHandling = cosmosSerializerOptions.IgnoreNullValues ? NullValueHandling.Ignore : NullValueHandling.Include,
@@ -47,7 +54,7 @@ internal CosmosJsonDotNetSerializer(CosmosSerializationOptions cosmosSerializerO
                     : null
             };
 
-            this.Serializer = JsonSerializer.Create(jsonSerializerSettings);
+            this.SerializerSettings = jsonSerializerSettings;
         }
 
         /// <summary>
@@ -59,7 +66,7 @@ internal CosmosJsonDotNetSerializer(CosmosSerializationOptions cosmosSerializerO
         /// </remarks>
         internal CosmosJsonDotNetSerializer(JsonSerializerSettings jsonSerializerSettings)
         {
-            this.Serializer = JsonSerializer.Create(jsonSerializerSettings);
+            this.SerializerSettings = jsonSerializerSettings ?? throw new ArgumentNullException(nameof(jsonSerializerSettings));
         }
 
         /// <summary>
@@ -81,7 +88,8 @@ public override T FromStream<T>(Stream stream)
                 {
                     using (JsonTextReader jsonTextReader = new JsonTextReader(sr))
                     {
-                        return this.Serializer.Deserialize<T>(jsonTextReader);
+                        JsonSerializer jsonSerializer = this.GetSerializer();
+                        return jsonSerializer.Deserialize<T>(jsonTextReader);
                     }
                 }
             }
@@ -101,7 +109,8 @@ public override Stream ToStream<T>(T input)
                 using (JsonWriter writer = new JsonTextWriter(streamWriter))
                 {
                     writer.Formatting = Newtonsoft.Json.Formatting.None;
-                    this.Serializer.Serialize(writer, input);
+                    JsonSerializer jsonSerializer = this.GetSerializer();
+                    jsonSerializer.Serialize(writer, input);
                     writer.Flush();
                     streamWriter.Flush();
                 }
@@ -110,5 +119,14 @@ public override Stream ToStream<T>(T input)
             streamPayload.Position = 0;
             return streamPayload;
         }
+
+        /// <summary>
+        /// JsonSerializer has hit a race conditions with custom settings that cause null reference exception.
+        /// To avoid the race condition a new JsonSerializer is created for each call
+        /// </summary>
+        private JsonSerializer GetSerializer()
+        {
+            return JsonSerializer.Create(this.SerializerSettings);
+        }
     }
 }

Microsoft.Azure.Cosmos/src/Serializer/CosmosSerializationOptions.cs

@@ -12,15 +12,19 @@ namespace Microsoft.Azure.Cosmos
     /// </summary>
     public sealed class CosmosSerializationOptions
     {
+        private const bool DefaultIgnoreNullValues = false;
+        private const bool DefaultIndented = false;
+        private const CosmosPropertyNamingPolicy DefaultCosmosPropertyNamingPolicy = CosmosPropertyNamingPolicy.Default;
+
         /// <summary>
         /// Create an instance of CosmosSerializationOptions
         /// with the default values for the Cosmos SDK
         /// </summary>
         public CosmosSerializationOptions()
         {
-            this.IgnoreNullValues = false;
-            this.Indented = false;
-            this.PropertyNamingPolicy = CosmosPropertyNamingPolicy.Default;
+            this.IgnoreNullValues = DefaultIgnoreNullValues;
+            this.Indented = DefaultIndented;
+            this.PropertyNamingPolicy = DefaultCosmosPropertyNamingPolicy;
         }
 
         /// <summary>
@@ -47,5 +51,15 @@ public CosmosSerializationOptions()
         /// The default value is CosmosPropertyNamingPolicy.Default
         /// </remarks>
         public CosmosPropertyNamingPolicy PropertyNamingPolicy { get; set; }
+
+        /// <summary>
+        /// Helper method to check if all the setting values are the default.
+        /// </summary>
+        internal bool IsDefaultSettings()
+        {
+            return this.IgnoreNullValues == DefaultIgnoreNullValues &&
+                this.Indented == DefaultIndented &&
+                this.PropertyNamingPolicy == DefaultCosmosPropertyNamingPolicy;
+        }
     }
 }

Microsoft.Azure.Cosmos/tests/Microsoft.Azure.Cosmos.Performance.Tests/Benchmarks/ItemBenchmark.cs

@@ -6,21 +6,27 @@ namespace Microsoft.Azure.Cosmos.Performance.Tests.Benchmarks
 {
     using System;
     using System.IO;
+    using System.Text;
     using System.Threading.Tasks;
     using BenchmarkDotNet.Attributes;
     using Microsoft.Azure.Cosmos;
+    using Microsoft.Azure.Documents.Collections;
+    using Newtonsoft.Json;
     using Newtonsoft.Json.Linq;
 
     /// <summary>
     /// Benchmark for Item related operations.
     /// </summary>
+    [MemoryDiagnoser]
     public class ItemBenchmark
     {
+        private static readonly Encoding DefaultEncoding = new UTF8Encoding(false, true);
         private readonly CosmosClient clientForTests;
         private readonly Container container;
+        private readonly JsonSerializer jsonSerializer = new JsonSerializer();
         private JObject baseItem;
         private byte[] payloadBytes;
-
+        private dynamic TestItem;
         /// <summary>
         /// Initializes a new instance of the <see cref="ItemBenchmark"/> class.
         /// </summary>
@@ -37,6 +43,53 @@ public ItemBenchmark()
                     this.payloadBytes = ms.ToArray();
                 }
             }
+
+            this.TestItem = new
+            {
+                id = "test",
+                pk = "what",
+                value = 1245,
+                stop = true,
+            };
+        }
+
+        [Benchmark]
+        public void StaticSerializeItem()
+        {
+            MemoryStream streamPayload = new MemoryStream();
+            using (StreamWriter streamWriter = new StreamWriter(streamPayload, encoding: ItemBenchmark.DefaultEncoding, bufferSize: 1024, leaveOpen: true))
+            {
+                using (JsonWriter writer = new JsonTextWriter(streamWriter))
+                {
+                    writer.Formatting = Newtonsoft.Json.Formatting.None;
+                    this.jsonSerializer.Serialize(writer, this.TestItem);
+                    writer.Flush();
+                    streamWriter.Flush();
+                }
+            }
+
+            streamPayload.Position = 0;
+            streamPayload.Dispose();
+        }
+
+        [Benchmark]
+        public void NewSerializeItem()
+        {
+            MemoryStream streamPayload = new MemoryStream();
+            using (StreamWriter streamWriter = new StreamWriter(streamPayload, encoding: ItemBenchmark.DefaultEncoding, bufferSize: 1024, leaveOpen: true))
+            {
+                using (JsonWriter writer = new JsonTextWriter(streamWriter))
+                {
+                    writer.Formatting = Newtonsoft.Json.Formatting.None;
+                    JsonSerializer jsonSerializer = new JsonSerializer();
+                    jsonSerializer.Serialize(writer, this.TestItem);
+                    writer.Flush();
+                    streamWriter.Flush();
+                }
+            }
+
+            streamPayload.Position = 0;
+            streamPayload.Dispose();
         }
 
         /// <summary>
@@ -83,7 +136,7 @@ public async Task UpsertItem()
         [Benchmark]
         public async Task UpsertItemStream()
         {
-            
+
             ResponseMessage response = await this.container.UpsertItemStreamAsync(
                     new MemoryStream(this.payloadBytes),
                     new Cosmos.PartitionKey(Constants.ValidOperationId));
@@ -134,7 +187,7 @@ public async Task UpdateItem()
         {
             ResponseMessage response = await this.container.ReplaceItemStreamAsync(
                 new MemoryStream(this.payloadBytes),
-                Constants.ValidOperationId, 
+                Constants.ValidOperationId,
                 new Cosmos.PartitionKey(Constants.ValidOperationId));
             if (response.StatusCode == System.Net.HttpStatusCode.NotFound || response.Content == null)
             {