CSHARP-3985: Support multiple SerializerRegistries

src/MongoDB.Bson/BsonDefaults.cs

@@ -42,7 +42,7 @@ public static IBsonSerializer DynamicArraySerializer
             {
                 if (!__dynamicArraySerializerWasSet)
                 {
-                    __dynamicArraySerializer = BsonSerializer.LookupSerializer<List<object>>();
+                    __dynamicArraySerializer = BsonSerializer.LookupSerializer<List<object>>();  //TODO I think we could keep this as is
                 }
                 return __dynamicArraySerializer;
             }
@@ -62,7 +62,7 @@ public static IBsonSerializer DynamicDocumentSerializer
             {
                 if (!__dynamicDocumentSerializerWasSet)
                 {
-                    __dynamicDocumentSerializer = BsonSerializer.LookupSerializer<ExpandoObject>();
+                    __dynamicDocumentSerializer = BsonSerializer.LookupSerializer<ExpandoObject>();   //TODO I think we could keep this as is
                 }
                 return __dynamicDocumentSerializer;
             }

src/MongoDB.Bson/BsonExtensionMethods.cs

@@ -84,7 +84,7 @@ public static byte[] ToBson(
 
             if (serializer == null)
             {
-                serializer = BsonSerializer.LookupSerializer(nominalType);
+                serializer = BsonSerializer.LookupSerializer(nominalType);   //TODO I think we need another method with the domain as input
             }
             if (serializer.ValueType != nominalType)
             {
@@ -165,7 +165,7 @@ public static BsonDocument ToBsonDocument(
                     return convertibleToBsonDocument.ToBsonDocument(); // use the provided ToBsonDocument method
                 }
 
-                serializer = BsonSerializer.LookupSerializer(nominalType);
+                serializer = BsonSerializer.LookupSerializer(nominalType);    //TODO I think we need another method with the domain as input
             }
             if (serializer.ValueType != nominalType)
             {
@@ -236,7 +236,7 @@ public static string ToJson(
 
             if (serializer == null)
             {
-                serializer = BsonSerializer.LookupSerializer(nominalType);
+                serializer = BsonSerializer.LookupSerializer(nominalType);    //TODO I think we need another method with the domain as input
             }
             if (serializer.ValueType != nominalType)
             {

src/MongoDB.Bson/ObjectModel/BsonDocumentWrapper.cs

@@ -104,7 +104,7 @@ public static BsonDocumentWrapper Create<TNominalType>(TNominalType value)
         /// <returns>A BsonDocumentWrapper.</returns>
         public static BsonDocumentWrapper Create(Type nominalType, object value)
         {
-            var serializer = BsonSerializer.LookupSerializer(nominalType);
+            var serializer = BsonSerializer.LookupSerializer(nominalType);  //TODO I think this could stay. We can potentially add methods with the domain as input.
             return new BsonDocumentWrapper(value, serializer);
         }
 
@@ -121,7 +121,7 @@ public static IEnumerable<BsonDocumentWrapper> CreateMultiple<TNominalType>(IEnu
                 throw new ArgumentNullException("values");
             }
 
-            var serializer = BsonSerializer.LookupSerializer(typeof(TNominalType));
+            var serializer = BsonSerializer.LookupSerializer(typeof(TNominalType)); //TODO I think this could stay. We can potentially add methods with the domain as input.
             return values.Select(v => new BsonDocumentWrapper(v, serializer));
         }
 
@@ -142,7 +142,7 @@ public static IEnumerable<BsonDocumentWrapper> CreateMultiple(Type nominalType,
                 throw new ArgumentNullException("values");
             }
 
-            var serializer = BsonSerializer.LookupSerializer(nominalType);
+            var serializer = BsonSerializer.LookupSerializer(nominalType); //TODO I think this could stay. We can potentially add methods with the domain as input.
             return values.Cast<object>().Select(v => new BsonDocumentWrapper(v, serializer));
         }
 

src/MongoDB.Bson/Serialization/BsonClassMap.cs

@@ -32,7 +32,7 @@ namespace MongoDB.Bson.Serialization
     public class BsonClassMap
     {
         // private static fields
-        private readonly static Dictionary<Type, BsonClassMap> __classMaps = new Dictionary<Type, BsonClassMap>();
+        private readonly static Dictionary<Type, BsonClassMap> __classMaps = new Dictionary<Type, BsonClassMap>();  //TODO I think the static fields and methods should not be here, but on the domain
         private readonly static Queue<Type> __knownTypesQueue = new Queue<Type>();
         private static int __freezeNestingLevel = 0;
 
@@ -284,7 +284,7 @@ public static Type GetMemberInfoType(MemberInfo memberInfo)
         /// <returns>All registered class maps.</returns>
         public static IEnumerable<BsonClassMap> GetRegisteredClassMaps()
         {
-            BsonSerializer.ConfigLock.EnterReadLock();
+            BsonSerializer.ConfigLock.EnterReadLock();  //TODO It would make sense to look at this after the PR by Robert is merged
             try
             {
                 return __classMaps.Values.ToList(); // return a copy for thread safety
@@ -375,7 +375,7 @@ public static BsonClassMap LookupClassMap(Type classType)
         /// </summary>
         /// <typeparam name="TClass">The class.</typeparam>
         /// <returns>The class map.</returns>
-        public static BsonClassMap<TClass> RegisterClassMap<TClass>()
+        public static BsonClassMap<TClass> RegisterClassMap<TClass>()  //TODO We should move the static methods here to IBSonSerializerDomain
         {
             return RegisterClassMap<TClass>(cm => { cm.AutoMap(); });
         }

src/MongoDB.Bson/Serialization/BsonDeserializationContext.cs

@@ -15,6 +15,8 @@
 
 using System;
 using MongoDB.Bson.IO;
+using MongoDB.Bson.Serialization.Options;
+using MongoDB.Bson.Serialization.Serializers;
 
 namespace MongoDB.Bson.Serialization
 {
@@ -28,18 +30,22 @@ public class BsonDeserializationContext
         private readonly IBsonSerializer _dynamicArraySerializer;
         private readonly IBsonSerializer _dynamicDocumentSerializer;
         private readonly IBsonReader _reader;
+        private readonly IBsonSerializationDomain _domain;
 
         // constructors
         private BsonDeserializationContext(
             IBsonReader reader,
             bool allowDuplicateElementNames,
             IBsonSerializer dynamicArraySerializer,
-            IBsonSerializer dynamicDocumentSerializer)
+            IBsonSerializer dynamicDocumentSerializer,
+            IBsonSerializationDomain domain)
         {
             _reader = reader;
             _allowDuplicateElementNames = allowDuplicateElementNames;
             _dynamicArraySerializer = dynamicArraySerializer;
             _dynamicDocumentSerializer = dynamicDocumentSerializer;
+            _domain = domain;
+            // _domain = domain ?? BsonSerializer.DefaultDomain;  //TODO We could do this here, but let's keep it as the previous line to catch errors.
         }
 
         // public properties
@@ -54,6 +60,11 @@ public bool AllowDuplicateElementNames
             get { return _allowDuplicateElementNames; }
         }
 
+        /// <summary>
+        /// //TODO
+        /// </summary>
+        public IBsonSerializationDomain Domain => _domain;
+
         /// <summary>
         /// Gets the dynamic array serializer.
         /// </summary>
@@ -138,6 +149,7 @@ public class Builder
             private IBsonSerializer _dynamicArraySerializer;
             private IBsonSerializer _dynamicDocumentSerializer;
             private IBsonReader _reader;
+            private IBsonSerializationDomain _domain;
 
             // constructors
             internal Builder(BsonDeserializationContext other, IBsonReader reader)
@@ -153,6 +165,7 @@ internal Builder(BsonDeserializationContext other, IBsonReader reader)
                     _allowDuplicateElementNames = other.AllowDuplicateElementNames;
                     _dynamicArraySerializer = other.DynamicArraySerializer;
                     _dynamicDocumentSerializer = other.DynamicDocumentSerializer;
+                    _domain = other.Domain;
                 }
                 else
                 {
@@ -209,14 +222,23 @@ public IBsonReader Reader
                 get { return _reader; }
             }
 
+            /// <summary>
+            /// //TODO
+            /// </summary>
+            public IBsonSerializationDomain Domain
+            {
+                get => _domain;
+                set => _domain = value;
+            }
+
             // public methods
             /// <summary>
             /// Builds the BsonDeserializationContext instance.
             /// </summary>
             /// <returns>A BsonDeserializationContext.</returns>
             internal BsonDeserializationContext Build()
             {
-                return new BsonDeserializationContext(_reader, _allowDuplicateElementNames, _dynamicArraySerializer, _dynamicDocumentSerializer);
+                return new BsonDeserializationContext(_reader, _allowDuplicateElementNames, _dynamicArraySerializer, _dynamicDocumentSerializer, _domain);
             }
         }
     }

src/MongoDB.Bson/Serialization/BsonMemberMap.cs

@@ -301,7 +301,7 @@ public IBsonSerializer GetSerializer()
                 // return special serializer for BsonValue members that handles the _csharpnull representation
                 if (_memberTypeIsBsonValue)
                 {
-                    var wrappedSerializer = BsonSerializer.LookupSerializer(_memberType);
+                    var wrappedSerializer = BsonSerializer.LookupSerializer(_memberType);   //TODO We need another version of this with the domain as input
                     var isBsonArraySerializer = wrappedSerializer is IBsonArraySerializer;
                     var isBsonDocumentSerializer = wrappedSerializer is IBsonDocumentSerializer;
 

src/MongoDB.Bson/Serialization/BsonSerializationContext.cs

@@ -26,17 +26,27 @@ public class BsonSerializationContext
         // private fields
         private readonly Func<Type, bool> _isDynamicType;
         private readonly IBsonWriter _writer;
+        private readonly IBsonSerializationDomain _domain;
 
         // constructors
         private BsonSerializationContext(
             IBsonWriter writer,
-            Func<Type, bool> isDynamicType)
+            Func<Type, bool> isDynamicType,
+            IBsonSerializationDomain domain)
         {
             _writer = writer;
             _isDynamicType = isDynamicType;
+            _domain = domain;
+            // _domain = domain ?? BsonSerializer.DefaultDomain;  //TODO We could do this here, but let's keep it as the previous line to catch errors.
         }
 
         // public properties
+
+        /// <summary>
+        /// //TODO
+        /// </summary>
+        public IBsonSerializationDomain Domain => _domain;
+
         /// <summary>
         /// Gets a function that, when executed, will indicate whether the type 
         /// is a dynamic type.
@@ -105,6 +115,7 @@ public class Builder
             // private fields
             private Func<Type, bool> _isDynamicType;
             private IBsonWriter _writer;
+            private IBsonSerializationDomain _domain;
 
             // constructors
             internal Builder(BsonSerializationContext other, IBsonWriter writer)
@@ -127,6 +138,15 @@ internal Builder(BsonSerializationContext other, IBsonWriter writer)
                 }
             }
 
+            /// <summary>
+            /// //TODO
+            /// </summary>
+            public IBsonSerializationDomain Domain
+            {
+                get => _domain;
+                set => _domain = value;
+            }
+
             // properties
             /// <summary>
             /// Gets or sets the function used to determine if a type is a dynamic type.
@@ -155,7 +175,7 @@ public IBsonWriter Writer
             /// <returns>A BsonSerializationContext.</returns>
             internal BsonSerializationContext Build()
             {
-                return new BsonSerializationContext(_writer, _isDynamicType);
+                return new BsonSerializationContext(_writer, _isDynamicType, _domain);
             }
         }
     }