CSHARP-3985: Support multiple SerializerRegistries

src/MongoDB.Bson/BsonDefaults.cs

@@ -24,71 +24,46 @@ namespace MongoDB.Bson
     /// </summary>
     public static class BsonDefaults
     {
-        // private static fields
-        private static bool __dynamicArraySerializerWasSet;
-        private static IBsonSerializer __dynamicArraySerializer;
-        private static bool __dynamicDocumentSerializerWasSet;
-        private static IBsonSerializer __dynamicDocumentSerializer;
-        private static int __maxDocumentSize = int.MaxValue;
-        private static int __maxSerializationDepth = 100;
-
         // public static properties
         /// <summary>
         /// Gets or sets the dynamic array serializer.
         /// </summary>
         public static IBsonSerializer DynamicArraySerializer
         {
-            get
-            {
-                if (!__dynamicArraySerializerWasSet)
-                {
-                    __dynamicArraySerializer = BsonSerializer.LookupSerializer<List<object>>();
-                }
-                return __dynamicArraySerializer;
-            }
-            set
-            {
-                __dynamicArraySerializerWasSet = true;
-                __dynamicArraySerializer = value;
-            }
+            get => BsonSerializer.DefaultSerializationDomain.BsonDefaults.DynamicArraySerializer;
+            set => BsonSerializer.DefaultSerializationDomain.BsonDefaults.DynamicArraySerializer = value;
         }
 
         /// <summary>
         /// Gets or sets the dynamic document serializer.
         /// </summary>
         public static IBsonSerializer DynamicDocumentSerializer
         {
-            get
-            {
-                if (!__dynamicDocumentSerializerWasSet)
-                {
-                    __dynamicDocumentSerializer = BsonSerializer.LookupSerializer<ExpandoObject>();
-                }
-                return __dynamicDocumentSerializer;
-            }
-            set
-            {
-                __dynamicDocumentSerializerWasSet = true;
-                __dynamicDocumentSerializer = value;
-            }
+            get => BsonSerializer.DefaultSerializationDomain.BsonDefaults.DynamicDocumentSerializer;
+            set => BsonSerializer.DefaultSerializationDomain.BsonDefaults.DynamicDocumentSerializer = value;
         }
 
+        /* DOMAIN-API We should modify the API to have those two values (and in the writer/reader settings where they are used) be nullable.
+         * The problem is that we need to now when these values have been set externally or not. If they have not, then they should
+         * be retrieved from the closest domain.
+         */
+
         /// <summary>
         /// Gets or sets the default max document size. The default is 4MiB.
         /// </summary>
         public static int MaxDocumentSize
         {
-            get { return __maxDocumentSize; }
-            set { __maxDocumentSize = value; }
+            get => BsonSerializer.DefaultSerializationDomain.BsonDefaults.MaxDocumentSize;
+            set => BsonSerializer.DefaultSerializationDomain.BsonDefaults.MaxDocumentSize = value;
         }
 
         /// <summary>
         /// Gets or sets the default max serialization depth (used to detect circular references during serialization). The default is 100.
         /// </summary>
         public static int MaxSerializationDepth
         {
-            get { return __maxSerializationDepth; }
-            set { __maxSerializationDepth = value; }
+            get => BsonSerializer.DefaultSerializationDomain.BsonDefaults.MaxSerializationDepth;
+            set => BsonSerializer.DefaultSerializationDomain.BsonDefaults.MaxSerializationDepth = value;
         }
     }
 }

src/MongoDB.Bson/BsonDefaultsDomain.cs

@@ -0,0 +1,73 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System.Collections.Generic;
+using System.Dynamic;
+using MongoDB.Bson.Serialization;
+
+namespace MongoDB.Bson
+{
+    internal class BsonDefaultsDomain : IBsonDefaults
+    {
+        private IBsonSerializationDomain _serializationDomain;
+        private bool _dynamicArraySerializerWasSet;
+        private IBsonSerializer _dynamicArraySerializer;
+        private bool _dynamicDocumentSerializerWasSet;
+        private IBsonSerializer _dynamicDocumentSerializer;
+
+        public BsonDefaultsDomain(IBsonSerializationDomain serializationDomain)
+        {
+            _serializationDomain = serializationDomain;
+        }
+
+        public IBsonSerializer DynamicArraySerializer
+        {
+            get
+            {
+                if (!_dynamicArraySerializerWasSet)
+                {
+                    _dynamicArraySerializer = _serializationDomain.LookupSerializer<List<object>>();
+                }
+                return _dynamicArraySerializer;
+            }
+            set
+            {
+                _dynamicArraySerializerWasSet = true;
+                _dynamicArraySerializer = value;
+            }
+        }
+
+        public IBsonSerializer DynamicDocumentSerializer
+        {
+            get
+            {
+                if (!_dynamicDocumentSerializerWasSet)
+                {
+                    _dynamicDocumentSerializer = _serializationDomain.LookupSerializer<ExpandoObject>();
+                }
+                return _dynamicDocumentSerializer;
+            }
+            set
+            {
+                _dynamicDocumentSerializerWasSet = true;
+                _dynamicDocumentSerializer = value;
+            }
+        }
+
+        public int MaxDocumentSize { get; set; } = int.MaxValue;
+
+        public int MaxSerializationDepth { get; set; } = 100;
+    }
+}

src/MongoDB.Bson/BsonExtensionMethods.cs

@@ -25,6 +25,8 @@ namespace MongoDB.Bson
     /// </summary>
     public static class BsonExtensionMethods
     {
+        //DOMAIN-API We should remove this and use the version with the domain.
+        //QUESTION: Do we want to do something now about this...? It's used also internally, but it seems in most cases it's used for "default serialization", so it should be ok.
         /// <summary>
         /// Serializes an object to a BSON byte array.
         /// </summary>
@@ -49,6 +51,21 @@ public static byte[] ToBson<TNominalType>(
             return ToBson(obj, typeof(TNominalType), writerSettings, serializer, configurator, args, estimatedBsonSize);
         }
 
+        internal static byte[] ToBson<TNominalType>(
+            this TNominalType obj,
+            IBsonSerializationDomain serializationDomain,
+            IBsonSerializer<TNominalType> serializer = null,
+            BsonBinaryWriterSettings writerSettings = null,
+            Action<BsonSerializationContext.Builder> configurator = null,
+            BsonSerializationArgs args = default(BsonSerializationArgs),
+            int estimatedBsonSize = 0)
+        {
+            args.SetOrValidateNominalType(typeof(TNominalType), "<TNominalType>");
+
+            return ToBson(obj, typeof(TNominalType), serializationDomain, writerSettings, serializer, configurator, args, estimatedBsonSize);
+        }
+
+        //DOMAIN-API We should remove this and use the version with the domain.
         /// <summary>
         /// Serializes an object to a BSON byte array.
         /// </summary>
@@ -68,6 +85,17 @@ public static byte[] ToBson(
             BsonBinaryWriterSettings writerSettings = null,
             IBsonSerializer serializer = null,
             Action<BsonSerializationContext.Builder> configurator = null,
+            BsonSerializationArgs args = default,
+            int estimatedBsonSize = 0) => ToBson(obj, nominalType, BsonSerializer.DefaultSerializationDomain, writerSettings,
+            serializer, configurator, args, estimatedBsonSize);
+
+        internal static byte[] ToBson(
+            this object obj,
+            Type nominalType,
+            IBsonSerializationDomain serializationDomain,
+            BsonBinaryWriterSettings writerSettings = null,
+            IBsonSerializer serializer = null,
+            Action<BsonSerializationContext.Builder> configurator = null,
             BsonSerializationArgs args = default(BsonSerializationArgs),
             int estimatedBsonSize = 0)
         {
@@ -84,7 +112,7 @@ public static byte[] ToBson(
 
             if (serializer == null)
             {
-                serializer = BsonSerializer.LookupSerializer(nominalType);
+                serializer = serializationDomain.LookupSerializer(nominalType);
             }
             if (serializer.ValueType != nominalType)
             {
@@ -96,7 +124,7 @@ public static byte[] ToBson(
             {
                 using (var bsonWriter = new BsonBinaryWriter(memoryStream, writerSettings ?? BsonBinaryWriterSettings.Defaults))
                 {
-                    var context = BsonSerializationContext.CreateRoot(bsonWriter, configurator);
+                    var context = BsonSerializationContext.CreateRoot(bsonWriter, serializationDomain, configurator);
                     serializer.Serialize(context, args, obj);
                 }
                 return memoryStream.ToArray();
@@ -138,7 +166,16 @@ public static BsonDocument ToBsonDocument(
             Type nominalType,
             IBsonSerializer serializer = null,
             Action<BsonSerializationContext.Builder> configurator = null,
-            BsonSerializationArgs args = default(BsonSerializationArgs))
+            BsonSerializationArgs args = default) => ToBsonDocument(obj, nominalType,
+            BsonSerializer.DefaultSerializationDomain, serializer, configurator, args);
+
+        internal static BsonDocument ToBsonDocument(
+            this object obj,
+            Type nominalType,
+            IBsonSerializationDomain serializationDomain,
+            IBsonSerializer serializer = null,
+            Action<BsonSerializationContext.Builder> configurator = null,
+            BsonSerializationArgs args = default)
         {
             if (nominalType == null)
             {
@@ -165,7 +202,7 @@ public static BsonDocument ToBsonDocument(
                     return convertibleToBsonDocument.ToBsonDocument(); // use the provided ToBsonDocument method
                 }
 
-                serializer = BsonSerializer.LookupSerializer(nominalType);
+                serializer = serializationDomain.LookupSerializer(nominalType);
             }
             if (serializer.ValueType != nominalType)
             {
@@ -177,7 +214,7 @@ public static BsonDocument ToBsonDocument(
             var document = new BsonDocument();
             using (var bsonWriter = new BsonDocumentWriter(document))
             {
-                var context = BsonSerializationContext.CreateRoot(bsonWriter, configurator);
+                var context = BsonSerializationContext.CreateRoot(bsonWriter, serializationDomain, configurator);
                 serializer.Serialize(context, args, obj);
             }
             return document;
@@ -226,6 +263,16 @@ public static string ToJson(
             JsonWriterSettings writerSettings = null,
             IBsonSerializer serializer = null,
             Action<BsonSerializationContext.Builder> configurator = null,
+            BsonSerializationArgs args = default)
+            => ToJson(obj, nominalType, BsonSerializer.DefaultSerializationDomain, writerSettings, serializer, configurator, args);
+
+        internal static string ToJson(
+            this object obj,
+            Type nominalType,
+            IBsonSerializationDomain domain,
+            JsonWriterSettings writerSettings = null,
+            IBsonSerializer serializer = null,
+            Action<BsonSerializationContext.Builder> configurator = null,
             BsonSerializationArgs args = default(BsonSerializationArgs))
         {
             if (nominalType == null)
@@ -236,7 +283,7 @@ public static string ToJson(
 
             if (serializer == null)
             {
-                serializer = BsonSerializer.LookupSerializer(nominalType);
+                serializer = domain.LookupSerializer(nominalType);
             }
             if (serializer.ValueType != nominalType)
             {
@@ -248,7 +295,7 @@ public static string ToJson(
             {
                 using (var bsonWriter = new JsonWriter(stringWriter, writerSettings ?? JsonWriterSettings.Defaults))
                 {
-                    var context = BsonSerializationContext.CreateRoot(bsonWriter, configurator);
+                    var context = BsonSerializationContext.CreateRoot(bsonWriter, domain, configurator);
                     serializer.Serialize(context, args, obj);
                 }
                 return stringWriter.ToString();

src/MongoDB.Bson/IBsonDefaults.cs

@@ -0,0 +1,39 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using MongoDB.Bson.Serialization;
+
+namespace MongoDB.Bson
+{
+    internal interface IBsonDefaults
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        IBsonSerializer DynamicArraySerializer { get; set; }
+        /// <summary>
+        ///
+        /// </summary>
+        IBsonSerializer DynamicDocumentSerializer { get; set; }
+        /// <summary>
+        ///
+        /// </summary>
+        int MaxDocumentSize { get; set; }
+        /// <summary>
+        ///
+        /// </summary>
+        int MaxSerializationDepth { get; set; }
+    }
+}

src/MongoDB.Bson/IO/BsonBinaryReaderSettings.cs

@@ -136,7 +136,7 @@ protected override BsonReaderSettings CloneImplementation()
                 Encoding = _encoding,
                 FixOldBinarySubTypeOnInput = _fixOldBinarySubTypeOnInput,
                 FixOldDateTimeMaxValueOnInput = _fixOldDateTimeMaxValueOnInput,
-                MaxDocumentSize = _maxDocumentSize
+                MaxDocumentSize = _maxDocumentSize,
             };
 
             return clone;

src/MongoDB.Bson/IO/BsonBinaryWriterSettings.cs

@@ -122,7 +122,7 @@ protected override BsonWriterSettings CloneImplementation()
                 Encoding = _encoding,
                 FixOldBinarySubTypeOnOutput = _fixOldBinarySubTypeOnOutput,
                 MaxDocumentSize = _maxDocumentSize,
-                MaxSerializationDepth = MaxSerializationDepth
+                MaxSerializationDepth = MaxSerializationDepth,
             };
             return clone;
         }

src/MongoDB.Bson/IO/BsonReader.cs

@@ -321,13 +321,15 @@ public virtual IByteBuffer ReadRawBsonArray()
             // overridden in BsonBinaryReader to read the raw bytes from the stream
             // for all other streams, deserialize the array and reserialize it using a BsonBinaryWriter to get the raw bytes
 
-            var deserializationContext = BsonDeserializationContext.CreateRoot(this);
+            //QUESTION Is it correct we only need a default domain here?
+            var deserializationContext = BsonDeserializationContext.CreateRoot(this, BsonSerializer.DefaultSerializationDomain);
             var array = BsonArraySerializer.Instance.Deserialize(deserializationContext);
 
             using (var memoryStream = new MemoryStream())
             using (var bsonWriter = new BsonBinaryWriter(memoryStream, BsonBinaryWriterSettings.Defaults))
             {
-                var serializationContext = BsonSerializationContext.CreateRoot(bsonWriter);
+                //QUESTION Is it correct we only need a default domain here?
+                var serializationContext = BsonSerializationContext.CreateRoot(bsonWriter, BsonSerializer.DefaultSerializationDomain);
                 bsonWriter.WriteStartDocument();
                 var startPosition = memoryStream.Position + 3; // just past BsonType, "x" and null byte
                 bsonWriter.WriteName("x");
@@ -351,7 +353,8 @@ public virtual IByteBuffer ReadRawBsonDocument()
             // overridden in BsonBinaryReader to read the raw bytes from the stream
             // for all other streams, deserialize the document and use ToBson to get the raw bytes
 
-            var deserializationContext = BsonDeserializationContext.CreateRoot(this);
+            //QUESTION Is it correct we only need a default domain here?
+            var deserializationContext = BsonDeserializationContext.CreateRoot(this, BsonSerializer.DefaultSerializationDomain);
             var document = BsonDocumentSerializer.Instance.Deserialize(deserializationContext);
             var bytes = document.ToBson();
             return new ByteArrayBuffer(bytes, isReadOnly: true);

src/MongoDB.Bson/IO/BsonReaderSettings.cs

@@ -14,6 +14,7 @@
 */
 
 using System;
+using MongoDB.Bson.Serialization;
 
 namespace MongoDB.Bson.IO
 {