Various improvements, and added test for discriminators.

papafe · papafe · commit 975545a61bcf · 2025-06-30T11:18:03.000+02:00
diff --git a/src/MongoDB.Bson/BsonExtensionMethods.cs b/src/MongoDB.Bson/BsonExtensionMethods.cs
@@ -77,7 +77,7 @@ public static byte[] ToBson(
         /// </summary>
         /// <param name="obj"></param>
         /// <param name="nominalType"></param>
-        /// <param name="domain"></param>
+        /// <param name="serializationDomain"></param>
         /// <param name="writerSettings"></param>
         /// <param name="serializer"></param>
         /// <param name="configurator"></param>
@@ -89,7 +89,7 @@ public static byte[] ToBson(
         public static byte[] ToBson(
             this object obj,
             Type nominalType,
-            IBsonSerializationDomain domain,
+            IBsonSerializationDomain serializationDomain,
             BsonBinaryWriterSettings writerSettings = null,
             IBsonSerializer serializer = null,
             Action<BsonSerializationContext.Builder> configurator = null,
@@ -109,7 +109,7 @@ public static byte[] ToBson(
 
             if (serializer == null)
             {
-                serializer = domain.LookupSerializer(nominalType);
+                serializer = serializationDomain.LookupSerializer(nominalType);
             }
             if (serializer.ValueType != nominalType)
             {
@@ -171,7 +171,7 @@ public static BsonDocument ToBsonDocument(
         /// </summary>
         /// <param name="obj"></param>
         /// <param name="nominalType"></param>
-        /// <param name="domain"></param>
+        /// <param name="serializationDomain"></param>
         /// <param name="serializer"></param>
         /// <param name="configurator"></param>
         /// <param name="args"></param>
@@ -181,7 +181,7 @@ public static BsonDocument ToBsonDocument(
         public static BsonDocument ToBsonDocument(
             this object obj,
             Type nominalType,
-            IBsonSerializationDomain domain,
+            IBsonSerializationDomain serializationDomain,
             IBsonSerializer serializer = null,
             Action<BsonSerializationContext.Builder> configurator = null,
             BsonSerializationArgs args = default)
@@ -211,7 +211,7 @@ public static BsonDocument ToBsonDocument(
                     return convertibleToBsonDocument.ToBsonDocument(); // use the provided ToBsonDocument method
                 }
 
-                serializer = domain.LookupSerializer(nominalType);
+                serializer = serializationDomain.LookupSerializer(nominalType);
             }
             if (serializer.ValueType != nominalType)
             {
diff --git a/src/MongoDB.Bson/IO/IBsonReader.cs b/src/MongoDB.Bson/IO/IBsonReader.cs
@@ -62,7 +62,7 @@ public interface IBsonReader : IDisposable
         /// <summary>
         /// Pops the settings.
         /// </summary>
-        void PopSettings();  //TODO Why do we have push and pop methods? They are not used
+        void PopSettings();  //TODO Why do we have push and pop methods? They are not used. We should remove them.
 
         /// <summary>
         /// Pushes new settings for the reader.
@@ -246,6 +246,14 @@ public interface IBsonReader : IDisposable
         /// <param name="bookmark">The bookmark.</param>
         void ReturnToBookmark(BsonReaderBookmark bookmark);
 
+        //TODO I'm not sure why this was not already present, there is already an equivalent in IBsonWriter.
+        //We can also avoid adding this to the interface and casting all the occurrences of IBsonReader to BsonReader (the base class for all readers in our codebase).
+        //Of course this would be a problem if someone implements IBsonReader in a different way.
+        /// <summary>
+        /// Gets the settings of the reader.
+        /// </summary>
+        BsonReaderSettings Settings { get; }
+
         /// <summary>
         /// Skips the name (reader must be positioned on a name).
         /// </summary>
diff --git a/src/MongoDB.Bson/Serialization/BsonClassMap.cs b/src/MongoDB.Bson/Serialization/BsonClassMap.cs
@@ -1161,7 +1161,7 @@ public void UnmapProperty(string propertyName)
         /// Gets the discriminator convention for the class.
         /// </summary>
         /// <returns>The discriminator convention for the class.</returns>
-        internal IDiscriminatorConvention GetDiscriminatorConvention()
+        internal IDiscriminatorConvention GetDiscriminatorConvention(IBsonSerializationDomainInternal serializationDomain)
         {
             // return a cached discriminator convention when possible
             var discriminatorConvention = _discriminatorConvention;
@@ -1198,7 +1198,7 @@ IDiscriminatorConvention LookupDiscriminatorConvention()
                         return classMap._discriminatorConvention;
                     }
 
-                    if (BsonSerializer.IsDiscriminatorConventionRegisteredAtThisLevel(classMap._classType))
+                    if (serializationDomain.IsDiscriminatorConventionRegisteredAtThisLevel(classMap._classType))
                     {
                         // in this case LookupDiscriminatorConvention below will find it
                         break;
@@ -1207,17 +1207,24 @@ IDiscriminatorConvention LookupDiscriminatorConvention()
                     if (classMap._isRootClass)
                     {
                         // in this case auto-register a hierarchical convention for the root class and look it up as usual below
-                        BsonSerializer.GetOrRegisterDiscriminatorConvention(classMap._classType, StandardDiscriminatorConvention.Hierarchical);
+                        serializationDomain.GetOrRegisterDiscriminatorConvention(classMap._classType, StandardDiscriminatorConvention.Hierarchical);
                         break;
                     }
 
                     classMap = classMap._baseClassMap;
                 }
 
-                return BsonSerializer.LookupDiscriminatorConvention(_classType);
+                return serializationDomain.LookupDiscriminatorConvention(_classType);
             }
         }
 
+        /// <summary>
+        /// Gets the discriminator convention for the class.
+        /// </summary>
+        /// <returns>The discriminator convention for the class.</returns>
+        internal IDiscriminatorConvention GetDiscriminatorConvention()
+            => GetDiscriminatorConvention(BsonSerializer.DefaultSerializationDomain as IBsonSerializationDomainInternal);
+
         // private methods
         private void AutoMapClass(IBsonSerializationDomain serializationDomain)
         {
diff --git a/src/MongoDB.Bson/Serialization/BsonClassMapDomain.cs b/src/MongoDB.Bson/Serialization/BsonClassMapDomain.cs
@@ -8,7 +8,7 @@ namespace MongoDB.Bson.Serialization;
 internal class BsonClassMapDomain : IBsonClassMapDomain
 {
     // private fields
-    private readonly IBsonSerializationDomain _serializationDomain;
+    private readonly IBsonSerializationDomainInternal _serializationDomain;
     private readonly Dictionary<Type, BsonClassMap> _classMaps = new();
 
     public BsonClassMapDomain(BsonSerializationDomain serializationDomain)
@@ -22,14 +22,14 @@ public BsonClassMapDomain(BsonSerializationDomain serializationDomain)
     /// <returns>All registered class maps.</returns>
     public IEnumerable<BsonClassMap> GetRegisteredClassMaps()
     {
-        BsonSerializer.ConfigLock.EnterReadLock();  //TODO It would make sense to look at this after the PR by Robert is merged
+        _serializationDomain.ConfigLock.EnterReadLock();
         try
         {
             return _classMaps.Values.ToList(); // return a copy for thread safety
         }
         finally
         {
-            BsonSerializer.ConfigLock.ExitReadLock();
+            _serializationDomain.ConfigLock.ExitReadLock();
         }
     }
 
@@ -45,14 +45,14 @@ public bool IsClassMapRegistered(Type type)
             throw new ArgumentNullException("type");
         }
 
-        BsonSerializer.ConfigLock.EnterReadLock();
+        _serializationDomain.ConfigLock.EnterReadLock();
         try
         {
             return _classMaps.ContainsKey(type);
         }
         finally
         {
-            BsonSerializer.ConfigLock.ExitReadLock();
+            _serializationDomain.ConfigLock.ExitReadLock();
         }
     }
 
@@ -68,7 +68,7 @@ public BsonClassMap LookupClassMap(Type classType)
             throw new ArgumentNullException("classType");
         }
 
-        BsonSerializer.ConfigLock.EnterReadLock();
+        _serializationDomain.ConfigLock.EnterReadLock(); //TODO Remove this lock from here...
         try
         {
             if (_classMaps.TryGetValue(classType, out var classMap))
@@ -81,7 +81,7 @@ public BsonClassMap LookupClassMap(Type classType)
         }
         finally
         {
-            BsonSerializer.ConfigLock.ExitReadLock();
+            _serializationDomain.ConfigLock.ExitReadLock();
         }
 
         // automatically create a new classMap for classType and register it (unless another thread does first)
@@ -91,7 +91,7 @@ public BsonClassMap LookupClassMap(Type classType)
         var newClassMap = (BsonClassMap)Activator.CreateInstance(classMapType);
         newClassMap.AutoMap(_serializationDomain);
 
-        BsonSerializer.ConfigLock.EnterWriteLock();
+        _serializationDomain.ConfigLock.EnterWriteLock();
         try
         {
             if (!_classMaps.TryGetValue(classType, out var classMap))
@@ -104,7 +104,7 @@ public BsonClassMap LookupClassMap(Type classType)
         }
         finally
         {
-            BsonSerializer.ConfigLock.ExitWriteLock();
+            _serializationDomain.ConfigLock.ExitWriteLock();
         }
     }
 
@@ -142,7 +142,7 @@ public void RegisterClassMap(BsonClassMap classMap)
             throw new ArgumentNullException("classMap");
         }
 
-        BsonSerializer.ConfigLock.EnterWriteLock();
+        _serializationDomain.ConfigLock.EnterWriteLock();
         try
         {
             // note: class maps can NOT be replaced (because derived classes refer to existing instance)
@@ -151,7 +151,7 @@ public void RegisterClassMap(BsonClassMap classMap)
         }
         finally
         {
-            BsonSerializer.ConfigLock.ExitWriteLock();
+            _serializationDomain.ConfigLock.ExitWriteLock();
         }
     }
 
@@ -227,7 +227,7 @@ public bool TryRegisterClassMap<TClass>(Func<BsonClassMap<TClass>> classMapFacto
             throw new ArgumentNullException(nameof(classMapFactory));
         }
 
-        BsonSerializer.ConfigLock.EnterReadLock();
+        _serializationDomain.ConfigLock.EnterReadLock();
         try
         {
             if (_classMaps.ContainsKey(typeof(TClass)))
@@ -237,10 +237,10 @@ public bool TryRegisterClassMap<TClass>(Func<BsonClassMap<TClass>> classMapFacto
         }
         finally
         {
-            BsonSerializer.ConfigLock.ExitReadLock();
+            _serializationDomain.ConfigLock.ExitReadLock();
         }
 
-        BsonSerializer.ConfigLock.EnterWriteLock();
+        _serializationDomain.ConfigLock.EnterWriteLock();
         try
         {
             if (_classMaps.ContainsKey(typeof(TClass)))
@@ -257,7 +257,7 @@ public bool TryRegisterClassMap<TClass>(Func<BsonClassMap<TClass>> classMapFacto
         }
         finally
         {
-            BsonSerializer.ConfigLock.ExitWriteLock();
+            _serializationDomain.ConfigLock.ExitWriteLock();
         }
     }
 }
diff --git a/src/MongoDB.Bson/Serialization/BsonDeserializationContext.cs b/src/MongoDB.Bson/Serialization/BsonDeserializationContext.cs
@@ -41,7 +41,7 @@ private BsonDeserializationContext(
             _allowDuplicateElementNames = allowDuplicateElementNames;
             _dynamicArraySerializer = dynamicArraySerializer;
             _dynamicDocumentSerializer = dynamicDocumentSerializer;
-            _serializationDomain = (reader as BsonReader)!.Settings?.SerializationDomain ?? BsonSerializer.DefaultSerializationDomain;
+            _serializationDomain = reader.Settings?.SerializationDomain ?? BsonSerializer.DefaultSerializationDomain;
         }
 
         // public properties
diff --git a/src/MongoDB.Bson/Serialization/BsonSerializationProviderBase.cs b/src/MongoDB.Bson/Serialization/BsonSerializationProviderBase.cs
@@ -26,7 +26,7 @@ public abstract class BsonSerializationProviderBase : IRegistryAwareBsonSerializ
         /// <inheritdoc/>
         public virtual IBsonSerializer GetSerializer(Type type)
         {
-            return GetSerializer(type, BsonSerializer.SerializerRegistry);   //TODO We can keep this as is
+            return GetSerializer(type, BsonSerializer.SerializerRegistry);   //TODO We can keep this as is? I think in the long run we should remove this overload.
         }
 
         /// <inheritdoc/>
@@ -40,7 +40,7 @@ public virtual IBsonSerializer GetSerializer(Type type)
         /// <returns>A serializer.</returns>
         protected virtual IBsonSerializer CreateGenericSerializer(Type serializerTypeDefinition, params Type[] typeArguments)
         {
-            return CreateGenericSerializer(serializerTypeDefinition, typeArguments, BsonSerializer.SerializerRegistry);   //TODO We can keep this as is
+            return CreateGenericSerializer(serializerTypeDefinition, typeArguments, BsonSerializer.SerializerRegistry);   //TODO We can keep this as is? I think in the long run we should remove this overload.
         }
 
         /// <summary>
@@ -65,7 +65,7 @@ protected virtual IBsonSerializer CreateGenericSerializer(Type serializerTypeDef
         /// <returns>A serializer.</returns>
         protected virtual IBsonSerializer CreateSerializer(Type serializerType)
         {
-            return CreateSerializer(serializerType, BsonSerializer.SerializerRegistry);   //TODO We can keep this as is
+            return CreateSerializer(serializerType, BsonSerializer.SerializerRegistry);   //TODO We can keep this as is? I think in the long run we should remove this overload.
         }
 
         /// <summary>
diff --git a/src/MongoDB.Bson/Serialization/Conventions/ScalarDiscriminatorConvention.cs b/src/MongoDB.Bson/Serialization/Conventions/ScalarDiscriminatorConvention.cs
@@ -43,7 +43,7 @@ public ScalarDiscriminatorConvention(string elementName)
         /// <param name="actualType">The actual type.</param>
         /// <returns>The discriminator value.</returns>
         public override BsonValue GetDiscriminator(Type nominalType, Type actualType) =>
-            GetDiscriminator(nominalType, actualType, BsonSerializer.DefaultSerializationDomain);
+            GetDiscriminator(nominalType, actualType, BsonSerializer.DefaultSerializationDomain);  //TODO method should not be used, remove it in the future
 
         /// <inheritdoc />
         public override BsonValue GetDiscriminator(Type nominalType, Type actualType, IBsonSerializationDomain domain)
diff --git a/src/MongoDB.Bson/Serialization/IBsonIdProvider.cs b/src/MongoDB.Bson/Serialization/IBsonIdProvider.cs
@@ -36,12 +36,12 @@ public interface IBsonIdProvider
         /// //TODO
         /// </summary>
         /// <param name="document"></param>
-        /// <param name="domain"></param>
+        /// <param name="serializationDomain"></param>
         /// <param name="id"></param>
         /// <param name="idNominalType"></param>
         /// <param name="idGenerator"></param>
         /// <returns></returns>
-        bool GetDocumentId(object document, IBsonSerializationDomain domain, out object id, out Type idNominalType, out IIdGenerator idGenerator);
+        bool GetDocumentId(object document, IBsonSerializationDomain serializationDomain, out object id, out Type idNominalType, out IIdGenerator idGenerator);
 
         /// <summary>
         /// Sets the document Id.
diff --git a/src/MongoDB.Bson/Serialization/IBsonSerializerExtensions.cs b/src/MongoDB.Bson/Serialization/IBsonSerializerExtensions.cs
@@ -58,7 +58,7 @@ public static TValue Deserialize<TValue>(this IBsonSerializer<TValue> serializer
         public static IDiscriminatorConvention GetDiscriminatorConvention(this IBsonSerializer serializer) =>
             serializer is IHasDiscriminatorConvention hasDiscriminatorConvention
                 ? hasDiscriminatorConvention.DiscriminatorConvention
-                : BsonSerializer.LookupDiscriminatorConvention(serializer.ValueType);   //TODO We can keep this as is
+                : BsonSerializer.LookupDiscriminatorConvention(serializer.ValueType);   //TODO We can keep this as is? In the long run this method should have the domain passed.
 
         /// <summary>
         /// Serializes a value.
diff --git a/src/MongoDB.Bson/Serialization/Serializers/BsonClassMapSerializer.cs b/src/MongoDB.Bson/Serialization/Serializers/BsonClassMapSerializer.cs
@@ -58,7 +58,7 @@ public BsonClassMapSerializer(BsonClassMap classMap)
 
         // public properties
         /// <inheritdoc/>
-        public IDiscriminatorConvention DiscriminatorConvention => _classMap.GetDiscriminatorConvention();
+        public IDiscriminatorConvention DiscriminatorConvention => _classMap.GetDiscriminatorConvention();  //TODO This should be removed, because we need to have the serialization domain.
 
         /// <summary>
         /// Gets a value indicating whether this serializer's discriminator is compatible with the object serializer.
@@ -88,7 +88,7 @@ public override TClass Deserialize(BsonDeserializationContext context, BsonDeser
                 return default(TClass);
             }
 
-            var discriminatorConvention = _classMap.GetDiscriminatorConvention();
+            var discriminatorConvention = _classMap.GetDiscriminatorConvention(context.SerializationDomain as IBsonSerializationDomainInternal);
 
             var actualType = discriminatorConvention.GetActualType(bsonReader, args.NominalType);
             if (actualType == typeof(TClass))
@@ -146,7 +146,7 @@ public TClass DeserializeClass(BsonDeserializationContext context)
                 }
             }
 
-            var discriminatorConvention = _classMap.GetDiscriminatorConvention();
+            var discriminatorConvention = _classMap.GetDiscriminatorConvention(context.SerializationDomain as IBsonSerializationDomainInternal);
             var allMemberMaps = _classMap.AllMemberMaps;
             var extraElementsMemberMapIndex = _classMap.ExtraElementsMemberMapIndex;
             var memberMapBitArray = FastMemberMapHelper.GetBitArray(allMemberMaps.Count);
@@ -329,7 +329,7 @@ public bool GetDocumentId(
             => GetDocumentId(document, BsonSerializer.DefaultSerializationDomain, out id, out idNominalType, out idGenerator);
 
         /// <inheritdoc/>
-        public bool GetDocumentId(object document, IBsonSerializationDomain domain, out object id, out Type idNominalType,
+        public bool GetDocumentId(object document, IBsonSerializationDomain serializationDomain, out object id, out Type idNominalType,
             out IIdGenerator idGenerator)
         {
             var idMemberMap = _classMap.IdMemberMap;
@@ -642,11 +642,11 @@ private void SerializeExtraElements(BsonSerializationContext context, object obj
 
         private void SerializeDiscriminator(BsonSerializationContext context, Type nominalType, object obj)
         {
-            var discriminatorConvention = _classMap.GetDiscriminatorConvention();
+            var discriminatorConvention = _classMap.GetDiscriminatorConvention(context.SerializationDomain as IBsonSerializationDomainInternal);
             if (discriminatorConvention != null)
             {
                 var actualType = obj.GetType();
-                var discriminator = discriminatorConvention.GetDiscriminator(nominalType, actualType);
+                var discriminator = discriminatorConvention.GetDiscriminator(nominalType, actualType, context.SerializationDomain);
                 if (discriminator != null)
                 {
                     context.Writer.WriteName(discriminatorConvention.ElementName);
diff --git a/src/MongoDB.Bson/Serialization/Serializers/BsonDocumentSerializer.cs b/src/MongoDB.Bson/Serialization/Serializers/BsonDocumentSerializer.cs
@@ -85,7 +85,7 @@ public bool GetDocumentId(
             out idNominalType, out idGenerator);
 
         /// <inheritdoc />
-        public bool GetDocumentId(object document, IBsonSerializationDomain domain, out object id, out Type idNominalType,
+        public bool GetDocumentId(object document, IBsonSerializationDomain serializationDomain, out object id, out Type idNominalType,
             out IIdGenerator idGenerator)
         {
             var bsonDocument = (BsonDocument)document;
@@ -94,7 +94,7 @@ public bool GetDocumentId(object document, IBsonSerializationDomain domain, out
             if (bsonDocument.TryGetValue("_id", out idBsonValue))
             {
                 id = idBsonValue;
-                idGenerator = domain.LookupIdGenerator(id.GetType());
+                idGenerator = serializationDomain.LookupIdGenerator(id.GetType());
 
                 if (idGenerator == null)
                 {
diff --git a/src/MongoDB.Bson/Serialization/Serializers/DictionarySerializerBase.cs b/src/MongoDB.Bson/Serialization/Serializers/DictionarySerializerBase.cs
diff --git a/src/MongoDB.Bson/Serialization/Serializers/DiscriminatedInterfaceSerializer.cs b/src/MongoDB.Bson/Serialization/Serializers/DiscriminatedInterfaceSerializer.cs
diff --git a/src/MongoDB.Bson/Serialization/Serializers/KeyValuePairSerializer.cs b/src/MongoDB.Bson/Serialization/Serializers/KeyValuePairSerializer.cs
diff --git a/src/MongoDB.Driver/OfTypeSerializer.cs b/src/MongoDB.Driver/OfTypeSerializer.cs
diff --git a/tests/MongoDB.Driver.Tests/MultipleRegistriesTests.cs b/tests/MongoDB.Driver.Tests/MultipleRegistriesTests.cs

Original file line number	Diff line number	Diff line change
`@@ -1161,7 +1161,7 @@ public void UnmapProperty(string propertyName)`
`1161`	`1161`	`/// Gets the discriminator convention for the class.`
`1162`	`1162`	`/// </summary>`
`1163`	`1163`	`/// <returns>The discriminator convention for the class.</returns>`
`1164`		`- internal IDiscriminatorConvention GetDiscriminatorConvention()`
	`1164`	`+ internal IDiscriminatorConvention GetDiscriminatorConvention(IBsonSerializationDomainInternal serializationDomain)`
`1165`	`1165`	`{`
`1166`	`1166`	`// return a cached discriminator convention when possible`
`1167`	`1167`	`var discriminatorConvention = _discriminatorConvention;`
`@@ -1198,7 +1198,7 @@ IDiscriminatorConvention LookupDiscriminatorConvention()`
`1198`	`1198`	`return classMap._discriminatorConvention;`
`1199`	`1199`	`}`
`1200`	`1200`
`1201`		`- if (BsonSerializer.IsDiscriminatorConventionRegisteredAtThisLevel(classMap._classType))`
	`1201`	`+ if (serializationDomain.IsDiscriminatorConventionRegisteredAtThisLevel(classMap._classType))`
`1202`	`1202`	`{`
`1203`	`1203`	`// in this case LookupDiscriminatorConvention below will find it`
`1204`	`1204`	`break;`
`@@ -1207,17 +1207,24 @@ IDiscriminatorConvention LookupDiscriminatorConvention()`
`1207`	`1207`	`if (classMap._isRootClass)`
`1208`	`1208`	`{`
`1209`	`1209`	`// in this case auto-register a hierarchical convention for the root class and look it up as usual below`
`1210`		`- BsonSerializer.GetOrRegisterDiscriminatorConvention(classMap._classType, StandardDiscriminatorConvention.Hierarchical);`
	`1210`	`+ serializationDomain.GetOrRegisterDiscriminatorConvention(classMap._classType, StandardDiscriminatorConvention.Hierarchical);`
`1211`	`1211`	`break;`
`1212`	`1212`	`}`
`1213`	`1213`
`1214`	`1214`	`classMap = classMap._baseClassMap;`
`1215`	`1215`	`}`
`1216`	`1216`
`1217`		`- return BsonSerializer.LookupDiscriminatorConvention(_classType);`
	`1217`	`+ return serializationDomain.LookupDiscriminatorConvention(_classType);`
`1218`	`1218`	`}`
`1219`	`1219`	`}`
`1220`	`1220`
	`1221`	`+ /// <summary>`
	`1222`	`+ /// Gets the discriminator convention for the class.`
	`1223`	`+ /// </summary>`
	`1224`	`+ /// <returns>The discriminator convention for the class.</returns>`
	`1225`	`+ internal IDiscriminatorConvention GetDiscriminatorConvention()`
	`1226`	`+ => GetDiscriminatorConvention(BsonSerializer.DefaultSerializationDomain as IBsonSerializationDomainInternal);`
	`1227`	`+`
`1221`	`1228`	`// private methods`
`1222`	`1229`	`private void AutoMapClass(IBsonSerializationDomain serializationDomain)`
`1223`	`1230`	`{`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ namespace MongoDB.Bson.Serialization;`
`8`	`8`	`internal class BsonClassMapDomain : IBsonClassMapDomain`
`9`	`9`	`{`
`10`	`10`	`// private fields`
`11`		`- private readonly IBsonSerializationDomain _serializationDomain;`
	`11`	`+ private readonly IBsonSerializationDomainInternal _serializationDomain;`
`12`	`12`	`private readonly Dictionary<Type, BsonClassMap> _classMaps = new();`
`13`	`13`
`14`	`14`	`public BsonClassMapDomain(BsonSerializationDomain serializationDomain)`
`@@ -22,14 +22,14 @@ public BsonClassMapDomain(BsonSerializationDomain serializationDomain)`
`22`	`22`	`/// <returns>All registered class maps.</returns>`
`23`	`23`	`public IEnumerable<BsonClassMap> GetRegisteredClassMaps()`
`24`	`24`	`{`
`25`		`- BsonSerializer.ConfigLock.EnterReadLock(); //TODO It would make sense to look at this after the PR by Robert is merged`
	`25`	`+ _serializationDomain.ConfigLock.EnterReadLock();`
`26`	`26`	`try`
`27`	`27`	`{`
`28`	`28`	`return _classMaps.Values.ToList(); // return a copy for thread safety`
`29`	`29`	`}`
`30`	`30`	`finally`
`31`	`31`	`{`
`32`		`- BsonSerializer.ConfigLock.ExitReadLock();`
	`32`	`+ _serializationDomain.ConfigLock.ExitReadLock();`
`33`	`33`	`}`
`34`	`34`	`}`
`35`	`35`
`@@ -45,14 +45,14 @@ public bool IsClassMapRegistered(Type type)`
`45`	`45`	`throw new ArgumentNullException("type");`
`46`	`46`	`}`
`47`	`47`
`48`		`- BsonSerializer.ConfigLock.EnterReadLock();`
	`48`	`+ _serializationDomain.ConfigLock.EnterReadLock();`
`49`	`49`	`try`
`50`	`50`	`{`
`51`	`51`	`return _classMaps.ContainsKey(type);`
`52`	`52`	`}`
`53`	`53`	`finally`
`54`	`54`	`{`
`55`		`- BsonSerializer.ConfigLock.ExitReadLock();`
	`55`	`+ _serializationDomain.ConfigLock.ExitReadLock();`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`@@ -68,7 +68,7 @@ public BsonClassMap LookupClassMap(Type classType)`
`68`	`68`	`throw new ArgumentNullException("classType");`
`69`	`69`	`}`
`70`	`70`
`71`		`- BsonSerializer.ConfigLock.EnterReadLock();`
	`71`	`+ _serializationDomain.ConfigLock.EnterReadLock(); //TODO Remove this lock from here...`
`72`	`72`	`try`
`73`	`73`	`{`
`74`	`74`	`if (_classMaps.TryGetValue(classType, out var classMap))`
`@@ -81,7 +81,7 @@ public BsonClassMap LookupClassMap(Type classType)`
`81`	`81`	`}`
`82`	`82`	`finally`
`83`	`83`	`{`
`84`		`- BsonSerializer.ConfigLock.ExitReadLock();`
	`84`	`+ _serializationDomain.ConfigLock.ExitReadLock();`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`// automatically create a new classMap for classType and register it (unless another thread does first)`
`@@ -91,7 +91,7 @@ public BsonClassMap LookupClassMap(Type classType)`
`91`	`91`	`var newClassMap = (BsonClassMap)Activator.CreateInstance(classMapType);`
`92`	`92`	`newClassMap.AutoMap(_serializationDomain);`
`93`	`93`
`94`		`- BsonSerializer.ConfigLock.EnterWriteLock();`
	`94`	`+ _serializationDomain.ConfigLock.EnterWriteLock();`
`95`	`95`	`try`
`96`	`96`	`{`
`97`	`97`	`if (!_classMaps.TryGetValue(classType, out var classMap))`
`@@ -104,7 +104,7 @@ public BsonClassMap LookupClassMap(Type classType)`
`104`	`104`	`}`
`105`	`105`	`finally`
`106`	`106`	`{`
`107`		`- BsonSerializer.ConfigLock.ExitWriteLock();`
	`107`	`+ _serializationDomain.ConfigLock.ExitWriteLock();`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`
`@@ -142,7 +142,7 @@ public void RegisterClassMap(BsonClassMap classMap)`
`142`	`142`	`throw new ArgumentNullException("classMap");`
`143`	`143`	`}`
`144`	`144`
`145`		`- BsonSerializer.ConfigLock.EnterWriteLock();`
	`145`	`+ _serializationDomain.ConfigLock.EnterWriteLock();`
`146`	`146`	`try`
`147`	`147`	`{`
`148`	`148`	`// note: class maps can NOT be replaced (because derived classes refer to existing instance)`
`@@ -151,7 +151,7 @@ public void RegisterClassMap(BsonClassMap classMap)`
`151`	`151`	`}`
`152`	`152`	`finally`
`153`	`153`	`{`
`154`		`- BsonSerializer.ConfigLock.ExitWriteLock();`
	`154`	`+ _serializationDomain.ConfigLock.ExitWriteLock();`
`155`	`155`	`}`
`156`	`156`	`}`
`157`	`157`
`@@ -227,7 +227,7 @@ public bool TryRegisterClassMap<TClass>(Func<BsonClassMap<TClass>> classMapFacto`
`227`	`227`	`throw new ArgumentNullException(nameof(classMapFactory));`
`228`	`228`	`}`
`229`	`229`
`230`		`- BsonSerializer.ConfigLock.EnterReadLock();`
	`230`	`+ _serializationDomain.ConfigLock.EnterReadLock();`
`231`	`231`	`try`
`232`	`232`	`{`
`233`	`233`	`if (_classMaps.ContainsKey(typeof(TClass)))`
`@@ -237,10 +237,10 @@ public bool TryRegisterClassMap<TClass>(Func<BsonClassMap<TClass>> classMapFacto`
`237`	`237`	`}`
`238`	`238`	`finally`
`239`	`239`	`{`
`240`		`- BsonSerializer.ConfigLock.ExitReadLock();`
	`240`	`+ _serializationDomain.ConfigLock.ExitReadLock();`
`241`	`241`	`}`
`242`	`242`
`243`		`- BsonSerializer.ConfigLock.EnterWriteLock();`
	`243`	`+ _serializationDomain.ConfigLock.EnterWriteLock();`
`244`	`244`	`try`
`245`	`245`	`{`
`246`	`246`	`if (_classMaps.ContainsKey(typeof(TClass)))`
`@@ -257,7 +257,7 @@ public bool TryRegisterClassMap<TClass>(Func<BsonClassMap<TClass>> classMapFacto`
`257`	`257`	`}`
`258`	`258`	`finally`
`259`	`259`	`{`
`260`		`- BsonSerializer.ConfigLock.ExitWriteLock();`
	`260`	`+ _serializationDomain.ConfigLock.ExitWriteLock();`
`261`	`261`	`}`
`262`	`262`	`}`
`263`	`263`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ private BsonDeserializationContext(`
`41`	`41`	`_allowDuplicateElementNames = allowDuplicateElementNames;`
`42`	`42`	`_dynamicArraySerializer = dynamicArraySerializer;`
`43`	`43`	`_dynamicDocumentSerializer = dynamicDocumentSerializer;`
`44`		`- _serializationDomain = (reader as BsonReader)!.Settings?.SerializationDomain ?? BsonSerializer.DefaultSerializationDomain;`
	`44`	`+ _serializationDomain = reader.Settings?.SerializationDomain ?? BsonSerializer.DefaultSerializationDomain;`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`// public properties`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public abstract class BsonSerializationProviderBase : IRegistryAwareBsonSerializ`
`26`	`26`	`/// <inheritdoc/>`
`27`	`27`	`public virtual IBsonSerializer GetSerializer(Type type)`
`28`	`28`	`{`
`29`		`- return GetSerializer(type, BsonSerializer.SerializerRegistry); //TODO We can keep this as is`
	`29`	`+ return GetSerializer(type, BsonSerializer.SerializerRegistry); //TODO We can keep this as is? I think in the long run we should remove this overload.`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`/// <inheritdoc/>`
`@@ -40,7 +40,7 @@ public virtual IBsonSerializer GetSerializer(Type type)`
`40`	`40`	`/// <returns>A serializer.</returns>`
`41`	`41`	`protected virtual IBsonSerializer CreateGenericSerializer(Type serializerTypeDefinition, params Type[] typeArguments)`
`42`	`42`	`{`
`43`		`- return CreateGenericSerializer(serializerTypeDefinition, typeArguments, BsonSerializer.SerializerRegistry); //TODO We can keep this as is`
	`43`	`+ return CreateGenericSerializer(serializerTypeDefinition, typeArguments, BsonSerializer.SerializerRegistry); //TODO We can keep this as is? I think in the long run we should remove this overload.`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`/// <summary>`
`@@ -65,7 +65,7 @@ protected virtual IBsonSerializer CreateGenericSerializer(Type serializerTypeDef`
`65`	`65`	`/// <returns>A serializer.</returns>`
`66`	`66`	`protected virtual IBsonSerializer CreateSerializer(Type serializerType)`
`67`	`67`	`{`
`68`		`- return CreateSerializer(serializerType, BsonSerializer.SerializerRegistry); //TODO We can keep this as is`
	`68`	`+ return CreateSerializer(serializerType, BsonSerializer.SerializerRegistry); //TODO We can keep this as is? I think in the long run we should remove this overload.`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ public BsonClassMapSerializer(BsonClassMap classMap)`
`58`	`58`
`59`	`59`	`// public properties`
`60`	`60`	`/// <inheritdoc/>`
`61`		`- public IDiscriminatorConvention DiscriminatorConvention => _classMap.GetDiscriminatorConvention();`
	`61`	`+ public IDiscriminatorConvention DiscriminatorConvention => _classMap.GetDiscriminatorConvention(); //TODO This should be removed, because we need to have the serialization domain.`
`62`	`62`
`63`	`63`	`/// <summary>`
`64`	`64`	`/// Gets a value indicating whether this serializer's discriminator is compatible with the object serializer.`
`@@ -88,7 +88,7 @@ public override TClass Deserialize(BsonDeserializationContext context, BsonDeser`
`88`	`88`	`return default(TClass);`
`89`	`89`	`}`
`90`	`90`
`91`		`- var discriminatorConvention = _classMap.GetDiscriminatorConvention();`
	`91`	`+ var discriminatorConvention = _classMap.GetDiscriminatorConvention(context.SerializationDomain as IBsonSerializationDomainInternal);`
`92`	`92`
`93`	`93`	`var actualType = discriminatorConvention.GetActualType(bsonReader, args.NominalType);`
`94`	`94`	`if (actualType == typeof(TClass))`
`@@ -146,7 +146,7 @@ public TClass DeserializeClass(BsonDeserializationContext context)`
`146`	`146`	`}`
`147`	`147`	`}`
`148`	`148`
`149`		`- var discriminatorConvention = _classMap.GetDiscriminatorConvention();`
	`149`	`+ var discriminatorConvention = _classMap.GetDiscriminatorConvention(context.SerializationDomain as IBsonSerializationDomainInternal);`
`150`	`150`	`var allMemberMaps = _classMap.AllMemberMaps;`
`151`	`151`	`var extraElementsMemberMapIndex = _classMap.ExtraElementsMemberMapIndex;`
`152`	`152`	`var memberMapBitArray = FastMemberMapHelper.GetBitArray(allMemberMaps.Count);`
`@@ -329,7 +329,7 @@ public bool GetDocumentId(`
`329`	`329`	`=> GetDocumentId(document, BsonSerializer.DefaultSerializationDomain, out id, out idNominalType, out idGenerator);`
`330`	`330`
`331`	`331`	`/// <inheritdoc/>`
`332`		`- public bool GetDocumentId(object document, IBsonSerializationDomain domain, out object id, out Type idNominalType,`
	`332`	`+ public bool GetDocumentId(object document, IBsonSerializationDomain serializationDomain, out object id, out Type idNominalType,`
`333`	`333`	`out IIdGenerator idGenerator)`
`334`	`334`	`{`
`335`	`335`	`var idMemberMap = _classMap.IdMemberMap;`
`@@ -642,11 +642,11 @@ private void SerializeExtraElements(BsonSerializationContext context, object obj`
`642`	`642`
`643`	`643`	`private void SerializeDiscriminator(BsonSerializationContext context, Type nominalType, object obj)`
`644`	`644`	`{`
`645`		`- var discriminatorConvention = _classMap.GetDiscriminatorConvention();`
	`645`	`+ var discriminatorConvention = _classMap.GetDiscriminatorConvention(context.SerializationDomain as IBsonSerializationDomainInternal);`
`646`	`646`	`if (discriminatorConvention != null)`
`647`	`647`	`{`
`648`	`648`	`var actualType = obj.GetType();`
`649`		`- var discriminator = discriminatorConvention.GetDiscriminator(nominalType, actualType);`
	`649`	`+ var discriminator = discriminatorConvention.GetDiscriminator(nominalType, actualType, context.SerializationDomain);`
`650`	`650`	`if (discriminator != null)`
`651`	`651`	`{`
`652`	`652`	`context.Writer.WriteName(discriminatorConvention.ElementName);`