Enabling serialization customization through CosmosSerializerOptions

Microsoft.Azure.Cosmos/src/CosmosClient.cs

@@ -150,7 +150,7 @@ protected CosmosClient()
         /// <seealso href="https://docs.microsoft.com/azure/cosmos-db/troubleshoot-dot-net-sdk"/>
         /// </remarks>
         public CosmosClient(
-            string connectionString, 
+            string connectionString,
             CosmosClientOptions clientOptions = null)
             : this(
                   CosmosClientOptions.GetAccountEndpoint(connectionString),
@@ -612,18 +612,19 @@ internal void Init(
 
             this.RequestHandler = clientPipelineBuilder.Build();
 
+            CosmosSerializer userSerializer = this.ClientOptions.GetCosmosSerializerWithWrapperOrDefault();
             this.ResponseFactory = new CosmosResponseFactory(
                 defaultJsonSerializer: this.ClientOptions.PropertiesSerializer,
-                userJsonSerializer: this.ClientOptions.CosmosSerializerWithWrapperOrDefault);
+                userJsonSerializer: userSerializer);
 
             CosmosSerializer sqlQuerySpecSerializer = CosmosSqlQuerySpecJsonConverter.CreateSqlQuerySpecSerializer(
-                this.ClientOptions.CosmosSerializerWithWrapperOrDefault,
-                this.ClientOptions.PropertiesSerializer);
+                cosmosSerializer: userSerializer,
+                propertiesSerializer: this.ClientOptions.PropertiesSerializer);
 
             this.ClientContext = new ClientContextCore(
                 client: this,
                 clientOptions: this.ClientOptions,
-                userJsonSerializer: this.ClientOptions.CosmosSerializerWithWrapperOrDefault,
+                userJsonSerializer: userSerializer,
                 defaultJsonSerializer: this.ClientOptions.PropertiesSerializer,
                 sqlQuerySpecSerializer: sqlQuerySpecSerializer,
                 cosmosResponseFactory: this.ResponseFactory,
@@ -632,7 +633,7 @@ internal void Init(
                 documentQueryClient: new DocumentQueryClient(this.DocumentClient));
         }
 
-        internal async virtual Task<ConsistencyLevel> GetAccountConsistencyLevelAsync()
+        internal virtual async Task<ConsistencyLevel> GetAccountConsistencyLevelAsync()
         {
             if (!this.accountConsistencyLevel.HasValue)
             {

Microsoft.Azure.Cosmos/src/CosmosClientOptions.cs

@@ -8,7 +8,6 @@ namespace Microsoft.Azure.Cosmos
     using System.Collections.ObjectModel;
     using System.Data.Common;
     using System.Linq;
-    using System.Runtime.ConstrainedExecution;
     using Microsoft.Azure.Cosmos.Fluent;
     using Microsoft.Azure.Documents;
     using Microsoft.Azure.Documents.Client;
@@ -39,11 +38,12 @@ public class CosmosClientOptions
         /// </summary>
         private static readonly CosmosSerializer propertiesSerializer = new CosmosJsonSerializerWrapper(new CosmosJsonDotNetSerializer());
 
-        private readonly Collection<RequestHandler> customHandlers;
         private readonly string currentEnvironmentInformation;
 
         private int gatewayModeMaxConnectionLimit;
         private string applicationName;
+        private CosmosSerializerOptions? serializerOptions;
+        private CosmosSerializer serializer;
 
         /// <summary>
         /// Creates a new CosmosClientOptions
@@ -59,7 +59,7 @@ public CosmosClientOptions()
             this.ConnectionMode = CosmosClientOptions.DefaultConnectionMode;
             this.ConnectionProtocol = CosmosClientOptions.DefaultProtocol;
             this.ApiType = CosmosClientOptions.DefaultApiType;
-            this.customHandlers = new Collection<RequestHandler>();
+            this.CustomHandlers = new Collection<RequestHandler>();
         }
 
         /// <summary>
@@ -132,10 +132,7 @@ public int GatewayModeMaxConnectionLimit
         /// </summary>
         /// <seealso cref="CosmosClientBuilder.AddCustomHandlers(RequestHandler[])"/>
         [JsonConverter(typeof(ClientOptionJsonConverter))]
-        public Collection<RequestHandler> CustomHandlers
-        {
-            get => this.customHandlers;
-        }
+        public Collection<RequestHandler> CustomHandlers { get; }
 
         /// <summary>
         /// Get or set the connection mode used by the client when connecting to the Azure Cosmos DB service.
@@ -157,7 +154,7 @@ public Collection<RequestHandler> CustomHandlers
         public ConsistencyLevel? ConsistencyLevel { get; set; }
 
         /// <summary>
-        /// Get ot set the number of times client should retry on rate throttled requests.
+        /// Get or set the number of times client should retry on rate throttled requests.
         /// </summary>
         /// <seealso cref="CosmosClientBuilder.WithThrottlingRetryOptions(TimeSpan, int)"/>
         public int? MaxRetryAttemptsOnRateLimitedRequests { get; set; }
@@ -171,6 +168,24 @@ public Collection<RequestHandler> CustomHandlers
         /// <seealso cref="CosmosClientBuilder.WithThrottlingRetryOptions(TimeSpan, int)"/>
         public TimeSpan? MaxRetryWaitTimeOnRateLimitedRequests { get; set; }
 
+        /// <summary>
+        /// Get to set an optional serializer options. 
+        /// </summary>
+        public CosmosSerializerOptions? SerializerOptions
+        {
+            get => this.serializerOptions;
+            set
+            {
+                if (this.Serializer != null)
+                {
+                    throw new ArgumentException(
+                        $"{nameof(this.SerializerOptions)} is not compatible with {nameof(this.Serializer)}. Only one can be set.  ");
+                }
+
+                this.serializerOptions = value;
+            }
+        }
+
         /// <summary>
         /// Get to set an optional JSON serializer. The client will use it to serialize or de-serialize user's cosmos request/responses.
         /// SDK owned types such as DatabaseProperties and ContainerProperties will always use the SDK default serializer.
@@ -182,10 +197,7 @@ public Collection<RequestHandler> CustomHandlers
         /// <example>
         /// // An example on how to configure the serializer to ignore null values
         /// CosmosSerializer ignoreNullSerializer = new CosmosJsonDotNetSerializer(
-        ///         new JsonSerializerSettings()
-        ///         {
-        ///             NullValueHandling = NullValueHandling.Ignore
-        ///         });
+        ///             NullValueHandling = NullValueHandling.Ignore);
         ///         
         /// CosmosClientOptions clientOptions = new CosmosClientOptions()
         /// {
@@ -195,7 +207,20 @@ public Collection<RequestHandler> CustomHandlers
         /// CosmosClient client = new CosmosClient("endpoint", "key", clientOptions);
         /// </example>
         [JsonConverter(typeof(ClientOptionJsonConverter))]
-        public CosmosSerializer Serializer { get; set; }
+        public CosmosSerializer Serializer
+        {
+            get => this.serializer;
+            set
+            {
+                if (this.SerializerOptions != null)
+                {
+                    throw new ArgumentException(
+                        $"{nameof(this.Serializer)} is not compatible with {nameof(this.SerializerOptions)}. Only one can be set.  ");
+                }
+
+                this.serializer = value;
+            }
+        }
 
         /// <summary>
         /// A JSON serializer used by the CosmosClient to serialize or de-serialize cosmos request/responses.
@@ -205,12 +230,6 @@ public Collection<RequestHandler> CustomHandlers
         [JsonConverter(typeof(ClientOptionJsonConverter))]
         internal CosmosSerializer PropertiesSerializer => CosmosClientOptions.propertiesSerializer;
 
-        /// <summary>
-        /// Gets the user json serializer with the CosmosJsonSerializerWrapper or the default
-        /// </summary>
-        [JsonIgnore]
-        internal CosmosSerializer CosmosSerializerWithWrapperOrDefault => this.Serializer == null ? this.PropertiesSerializer : new CosmosJsonSerializerWrapper(this.Serializer);
-
         /// <summary>
         /// Gets or sets the connection protocol when connecting to the Azure Cosmos service.
         /// </summary>
@@ -309,6 +328,22 @@ public Collection<RequestHandler> CustomHandlers
         /// </summary>
         internal bool? EnableCpuMonitor { get; set; }
 
+        /// <summary>
+        /// Gets the user json serializer with the CosmosJsonSerializerWrapper or the default
+        /// </summary>
+        internal CosmosSerializer GetCosmosSerializerWithWrapperOrDefault()
+        {
+            if (this.SerializerOptions != null)
+            {
+                CosmosJsonDotNetSerializer cosmosJsonDotNetSerializer = new CosmosJsonDotNetSerializer(this.SerializerOptions.Value);
+                return new CosmosJsonSerializerWrapper(cosmosJsonDotNetSerializer);
+            }
+            else
+            {
+                return this.Serializer == null ? this.PropertiesSerializer : new CosmosJsonSerializerWrapper(this.Serializer);
+            }
+        }
+
         internal CosmosClientOptions Clone()
         {
             CosmosClientOptions cloneConfiguration = (CosmosClientOptions)this.MemberwiseClone();

Microsoft.Azure.Cosmos/src/DocumentClientWithUriParameters.cs

@@ -6,13 +6,11 @@ namespace Microsoft.Azure.Cosmos
 {
     using System;
     using System.Globalization;
-    using System.IO;
     using System.Linq;
     using System.Net;
     using System.Threading;
     using System.Threading.Tasks;
     using Microsoft.Azure.Cosmos.Linq;
-    using Microsoft.Azure.Cosmos.Scripts;
     using Microsoft.Azure.Documents;
     using Microsoft.Azure.Documents.Client;
 
@@ -64,7 +62,7 @@ public Task<ResourceResponse<DocumentCollection>> CreateDocumentCollectionAsync(
         /// <returns>The <see cref="DocumentCollection"/> that was created contained within a <see cref="System.Threading.Tasks.Task"/> object representing the service response for the asynchronous operation.</returns>
         public Task<ResourceResponse<DocumentCollection>> CreateDocumentCollectionIfNotExistsAsync(Uri databaseUri, DocumentCollection documentCollection, Documents.Client.RequestOptions options = null)
         {
-            return TaskHelper.InlineIfPossible(() => CreateDocumentCollectionIfNotExistsPrivateAsync(databaseUri, documentCollection, options), null);
+            return TaskHelper.InlineIfPossible(() => this.CreateDocumentCollectionIfNotExistsPrivateAsync(databaseUri, documentCollection, options), null);
         }
 
         private async Task<ResourceResponse<DocumentCollection>> CreateDocumentCollectionIfNotExistsPrivateAsync(
@@ -74,7 +72,7 @@ private async Task<ResourceResponse<DocumentCollection>> CreateDocumentCollectio
             {
                 throw new ArgumentNullException("databaseUri");
             }
-            
+
             if (documentCollection == null)
             {
                 throw new ArgumentNullException("documentCollection");
@@ -84,7 +82,7 @@ private async Task<ResourceResponse<DocumentCollection>> CreateDocumentCollectio
                      databaseUri.OriginalString, Paths.CollectionsPathSegment, Uri.EscapeUriString(documentCollection.Id)), UriKind.Relative);
 
             try
-            {   
+            {
                 return await this.ReadDocumentCollectionAsync(documentCollectionUri, options);
             }
             catch (DocumentClientException dce)
@@ -403,9 +401,9 @@ public Task<ResourceResponse<DocumentCollection>> ReplaceDocumentCollectionAsync
 
             IDocumentClientRetryPolicy retryPolicyInstance = this.ResetSessionTokenRetryPolicy.GetRequestPolicy();
             return TaskHelper.InlineIfPossible(() => this.ReplaceDocumentCollectionPrivateAsync(
-                documentCollection, 
-                options, 
-                retryPolicyInstance, 
+                documentCollection,
+                options,
+                retryPolicyInstance,
                 documentCollectionUri.OriginalString), retryPolicyInstance);
         }
 
@@ -425,11 +423,11 @@ public Task<ResourceResponse<StoredProcedure>> ReplaceStoredProcedureAsync(Uri s
 
             IDocumentClientRetryPolicy retryPolicyInstance = this.ResetSessionTokenRetryPolicy.GetRequestPolicy();
             return TaskHelper.InlineIfPossible(() => this.ReplaceStoredProcedurePrivateAsync(
-                storedProcedure, 
-                options, 
+                storedProcedure,
+                options,
                 retryPolicyInstance,
                 storedProcedureUri.OriginalString), retryPolicyInstance);
-       }
+        }
 
         /// <summary>
         /// Replaces a trigger as an asynchronous operation in the Azure Cosmos DB service.
@@ -465,7 +463,7 @@ public Task<ResourceResponse<UserDefinedFunction>> ReplaceUserDefinedFunctionAsy
 
             IDocumentClientRetryPolicy retryPolicyInstance = this.ResetSessionTokenRetryPolicy.GetRequestPolicy();
             return TaskHelper.InlineIfPossible(() => this.ReplaceUserDefinedFunctionPrivateAsync(function, options, retryPolicyInstance, userDefinedFunctionUri.OriginalString), retryPolicyInstance);
-       }
+        }
 
         /// <summary>
         /// Replaces a user defined type as an asynchronous operation in the Azure Cosmos DB service.
@@ -1234,7 +1232,7 @@ internal Task<DocumentFeedResponse<Schema>> ReadSchemaFeedAsync(Uri schemasUri,
         /// <param name="databaseUri">the URI to the database.</param>
         /// <param name="feedOptions">The options for processing the query results feed.</param>
         /// <returns>The query result set.</returns>
-        public IOrderedQueryable<DocumentCollection> CreateDocumentCollectionQuery(Uri databaseUri,  FeedOptions feedOptions = null)
+        public IOrderedQueryable<DocumentCollection> CreateDocumentCollectionQuery(Uri databaseUri, FeedOptions feedOptions = null)
         {
             if (databaseUri == null)
             {

Microsoft.Azure.Cosmos/src/Fluent/CosmosClientBuilder.cs

@@ -255,6 +255,20 @@ public CosmosClientBuilder WithThrottlingRetryOptions(TimeSpan maxRetryWaitTimeO
             return this;
         }
 
+        /// <summary>
+        /// Set a custom serializer option. 
+        /// </summary>
+        /// <param name="cosmosSerializerOptions">The custom class that implements <see cref="CosmosSerializer"/> </param>
+        /// <returns>The <see cref="CosmosClientBuilder"/> object</returns>
+        /// <seealso cref="CosmosSerializer"/>
+        /// <seealso cref="CosmosClientOptions.SerializerOptions"/>
+        public CosmosClientBuilder WithSerializerOptions(
+            CosmosSerializerOptions cosmosSerializerOptions)
+        {
+            this.clientOptions.SerializerOptions = cosmosSerializerOptions;
+            return this;
+        }
+
         /// <summary>
         /// Set a custom JSON serializer. 
         /// </summary>

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

@@ -7,32 +7,62 @@ namespace Microsoft.Azure.Cosmos
     using System.IO;
     using System.Text;
     using Newtonsoft.Json;
+    using Newtonsoft.Json.Serialization;
 
     /// <summary>
-    /// The default Cosmos JSON.NET serializer
+    /// The default Cosmos JSON.NET serializer.
     /// </summary>
-    public sealed class CosmosJsonDotNetSerializer : CosmosSerializer
+    internal sealed class CosmosJsonDotNetSerializer : CosmosSerializer
     {
         private static readonly Encoding DefaultEncoding = new UTF8Encoding(false, true);
         private readonly JsonSerializer Serializer;
 
         /// <summary>
         /// Create a serializer that uses the JSON.net serializer
         /// </summary>
-        /// <param name="jsonSerializerSettings">Optional serializer settings</param>
-        public CosmosJsonDotNetSerializer(JsonSerializerSettings jsonSerializerSettings = null)
+        /// <remarks>
+        /// This is internal to reduce exposure of JSON.net types so
+        /// it is easier to convert to System.Text.Json
+        /// </remarks>
+        internal CosmosJsonDotNetSerializer()
         {
-            if (jsonSerializerSettings == null)
+            this.Serializer = JsonSerializer.Create();
+        }
+
+        /// <summary>
+        /// Create a serializer that uses the JSON.net serializer
+        /// </summary>
+        /// <remarks>
+        /// This is internal to reduce exposure of JSON.net types so
+        /// it is easier to convert to System.Text.Json
+        /// </remarks>
+        internal CosmosJsonDotNetSerializer(
+            CosmosSerializerOptions cosmosSerializerOptions)
+        {
+            JsonSerializerSettings jsonSerializerSettings = new JsonSerializerSettings()
             {
-                jsonSerializerSettings = new JsonSerializerSettings()
-                {
-                    NullValueHandling = NullValueHandling.Include
-                };
-            }
+                NullValueHandling = cosmosSerializerOptions.IgnoreNullValues ? NullValueHandling.Ignore : NullValueHandling.Include,
+                Formatting = cosmosSerializerOptions.Indented ? Formatting.Indented : Formatting.None,
+                ContractResolver = cosmosSerializerOptions.PropertyNamingPolicy == CosmosPropertyNamingPolicy.CamelCase
+                    ? new CamelCasePropertyNamesContractResolver() : null,
+            };
 
             this.Serializer = JsonSerializer.Create(jsonSerializerSettings);
         }
 
+        /// <summary>
+        /// Create a serializer that uses the JSON.net serializer
+        /// </summary>
+        /// <remarks>
+        /// This is internal to reduce exposure of JSON.net types so
+        /// it is easier to convert to System.Text.Json
+        /// </remarks>
+        internal CosmosJsonDotNetSerializer(
+            JsonSerializerSettings jsonSerializerSettings)
+        {
+            this.Serializer = JsonSerializer.Create(jsonSerializerSettings);
+        }
+
         /// <summary>
         /// Convert a Stream to the passed in type.
         /// </summary>
@@ -45,7 +75,7 @@ public override T FromStream<T>(Stream stream)
             {
                 if (typeof(Stream).IsAssignableFrom(typeof(T)))
                 {
-                    return (T)(object)(stream);
+                    return (T)(object)stream;
                 }
 
                 using (StreamReader sr = new StreamReader(stream))