Merged IBsonSerializationDomainInternal into IBsonSerializationDomain and created GetDiscriminatorsForTypeAndSubTypesInternal.

papafe · papafe · commit 3ea1228fe32d · 2025-06-28T11:09:11.000+02:00
diff --git a/src/MongoDB.Bson/InternalExtensions.cs b/src/MongoDB.Bson/InternalExtensions.cs
@@ -20,9 +20,11 @@
 
 namespace MongoDB.Bson
 {
-    //FP This could be moved somewhere else
+    //FP This could be moved somewhere else, and maybe reordered.
     internal static class InternalExtensions
     {
+        #region IDiscriminatorConvention
+
         public static Type GetActualTypeInternal(this IDiscriminatorConvention discriminatorConvention, IBsonReader bsonReader, Type nominalType, IBsonSerializationDomain serializationDomain)
         {
             if (discriminatorConvention is IDiscriminatorConventionInternal internalConvention)
@@ -41,6 +43,23 @@ public static BsonValue GetDiscriminatorInternal(this IDiscriminatorConvention d
             return discriminatorConvention.GetDiscriminator(nominalType, actualType);
         }
 
+        #endregion
+
+        #region IScalarDiscriminatorConvention
+
+        public static BsonValue[] GetDiscriminatorsForTypeAndSubTypesInternal(this IScalarDiscriminatorConvention discriminatorConvention, Type type, IBsonSerializationDomain serializationDomain)
+        {
+            if (discriminatorConvention is IScalarDiscriminatorConventionInternal internalConvention)
+            {
+                return internalConvention.GetDiscriminatorsForTypeAndSubTypes(type, serializationDomain);
+            }
+            return discriminatorConvention.GetDiscriminatorsForTypeAndSubTypes(type);
+        }
+
+        #endregion
+
+        #region IMemberMapConvention
+
         public static void ApplyInternal(this IMemberMapConvention memberMapConvention, BsonMemberMap memberMap, IBsonSerializationDomain serializationDomain)
         {
             if (memberMapConvention is IMemberMapConventionInternal internalConvention)
@@ -53,6 +72,10 @@ public static void ApplyInternal(this IMemberMapConvention memberMapConvention,
             }
         }
 
+        #endregion
+
+        #region IPostProcessingConvention
+
         public static void PostProcessInternal(this IPostProcessingConvention postProcessingConvention, BsonClassMap classMap, IBsonSerializationDomain serializationDomain)
         {
             if (postProcessingConvention is IPostProcessingConventionInternal internalConvention)
@@ -64,5 +87,7 @@ public static void PostProcessInternal(this IPostProcessingConvention postProces
                 postProcessingConvention.PostProcess(classMap);
             }
         }
+
+        #endregion
     }
 }
diff --git a/src/MongoDB.Bson/Serialization/BsonClassMap.cs b/src/MongoDB.Bson/Serialization/BsonClassMap.cs
@@ -415,16 +415,16 @@ internal class FreezeContext
         {
             public int FreezeNestingLevel { get; set; } = 0;
             public Queue<Type> KnownTypesQueue { get; set; } = new();
-            public IBsonSerializationDomainInternal SerializationDomain { get; set; }
+            public IBsonSerializationDomain SerializationDomain { get; set; }
         }
 
         /// <summary>
         /// Freezes the class map.
         /// </summary>
         /// <returns>The frozen class map.</returns>
-        public BsonClassMap Freeze() => Freeze(BsonSerializer.DefaultSerializationDomain as IBsonSerializationDomainInternal);
+        public BsonClassMap Freeze() => Freeze(BsonSerializer.DefaultSerializationDomain);
 
-        internal BsonClassMap Freeze(IBsonSerializationDomainInternal domain)
+        internal BsonClassMap Freeze(IBsonSerializationDomain domain)
         {
             var freezeContext = new FreezeContext { SerializationDomain = domain };
             return Freeze(freezeContext);
@@ -1171,7 +1171,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(IBsonSerializationDomainInternal serializationDomain)
+        internal IDiscriminatorConvention GetDiscriminatorConvention(IBsonSerializationDomain serializationDomain)
         {
             // return a cached discriminator convention when possible
             var discriminatorConvention = _discriminatorConvention;
@@ -1218,7 +1218,7 @@ IDiscriminatorConvention LookupDiscriminatorConvention()
         /// </summary>
         /// <returns>The discriminator convention for the class.</returns>
         internal IDiscriminatorConvention GetDiscriminatorConvention()
-            => GetDiscriminatorConvention(BsonSerializer.DefaultSerializationDomain as IBsonSerializationDomainInternal);
+            => GetDiscriminatorConvention(BsonSerializer.DefaultSerializationDomain);
 
         // 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 IBsonSerializationDomainInternal _serializationDomain;
+    private readonly IBsonSerializationDomain _serializationDomain;
     private readonly Dictionary<Type, BsonClassMap> _classMaps = new();
 
     public BsonClassMapDomain(BsonSerializationDomain serializationDomain)
diff --git a/src/MongoDB.Bson/Serialization/BsonSerializationDomain.cs b/src/MongoDB.Bson/Serialization/BsonSerializationDomain.cs
@@ -15,7 +15,7 @@ namespace MongoDB.Bson.Serialization
     /// <summary>
     /// A class that represents the BSON serialization functionality.
     /// </summary>
-    internal class BsonSerializationDomain : IBsonSerializationDomainInternal, IDisposable
+    internal class BsonSerializationDomain : IBsonSerializationDomain, IDisposable
     {
         // private fields
         private IBsonDefaults _bsonDefaults;
diff --git a/src/MongoDB.Bson/Serialization/BsonSerializer.cs b/src/MongoDB.Bson/Serialization/BsonSerializer.cs
@@ -26,7 +26,7 @@ namespace MongoDB.Bson.Serialization
     /// </summary>
     public static class BsonSerializer
     {
-        private static readonly IBsonSerializationDomainInternal _serializationDomain;
+        private static readonly IBsonSerializationDomain _serializationDomain;
 
         // static constructor
         static BsonSerializer()
diff --git a/src/MongoDB.Bson/Serialization/Conventions/IScalarDiscriminatorConvention.cs b/src/MongoDB.Bson/Serialization/Conventions/IScalarDiscriminatorConvention.cs
@@ -27,6 +27,11 @@ public interface IScalarDiscriminatorConvention : IDiscriminatorConvention
         /// </summary>
         /// <param name="type">The type.</param>
         /// <returns>The discriminators.</returns>
-        BsonValue[] GetDiscriminatorsForTypeAndSubTypes(Type type);  //FP Need to fix this....
+        BsonValue[] GetDiscriminatorsForTypeAndSubTypes(Type type);
+    }
+
+    internal interface IScalarDiscriminatorConventionInternal : IScalarDiscriminatorConvention
+    {
+        BsonValue[] GetDiscriminatorsForTypeAndSubTypes(Type type, IBsonSerializationDomain serializationDomain);
     }
 }
diff --git a/src/MongoDB.Bson/Serialization/Conventions/ScalarDiscriminatorConvention.cs b/src/MongoDB.Bson/Serialization/Conventions/ScalarDiscriminatorConvention.cs
@@ -22,7 +22,7 @@ namespace MongoDB.Bson.Serialization.Conventions
     /// <summary>
     /// Represents a discriminator convention where the discriminator is provided by the class map of the actual type.
     /// </summary>
-    public class ScalarDiscriminatorConvention : StandardDiscriminatorConvention, IScalarDiscriminatorConvention, IDiscriminatorConventionInternal
+    public class ScalarDiscriminatorConvention : StandardDiscriminatorConvention, IScalarDiscriminatorConventionInternal, IDiscriminatorConventionInternal
     {
         private readonly ConcurrentDictionary<Type, BsonValue[]> _cachedTypeAndSubTypeDiscriminators = new();
 
@@ -67,9 +67,12 @@ BsonValue IDiscriminatorConventionInternal.GetDiscriminator(Type nominalType, Ty
         }
 
         /// <inheritdoc/>
-        public BsonValue[] GetDiscriminatorsForTypeAndSubTypes(Type type)
+        public BsonValue[] GetDiscriminatorsForTypeAndSubTypes(Type type) =>
+            (this as IScalarDiscriminatorConventionInternal).GetDiscriminatorsForTypeAndSubTypes(type, BsonSerializer.DefaultSerializationDomain);
+
+        BsonValue[] IScalarDiscriminatorConventionInternal.GetDiscriminatorsForTypeAndSubTypes(Type type, IBsonSerializationDomain serializationDomain)
         {
-            return _cachedTypeAndSubTypeDiscriminators.GetOrAdd(type, BsonSerializer.GetDiscriminatorsForTypeAndSubTypes);
+            return _cachedTypeAndSubTypeDiscriminators.GetOrAdd(type, serializationDomain.GetDiscriminatorsForTypeAndSubTypes);
         }
     }
 }
diff --git a/src/MongoDB.Bson/Serialization/Conventions/StandardDiscriminatorConvention.cs b/src/MongoDB.Bson/Serialization/Conventions/StandardDiscriminatorConvention.cs
@@ -104,7 +104,7 @@ internal Type GetActualType(IBsonReader bsonReader, Type nominalType, IBsonSeria
             if (bsonType == BsonType.Document)
             {
                 // ensure KnownTypes of nominalType are registered (so IsTypeDiscriminated returns correct answer)
-                (domain as IBsonSerializationDomainInternal)!.EnsureKnownTypesAreRegistered(nominalType);  //TODO Should we move Ensure... to the public interface?
+                domain.EnsureKnownTypesAreRegistered(nominalType);
 
                 // we can skip looking for a discriminator if nominalType has no discriminated sub types
                 if (domain.IsTypeDiscriminated(nominalType))
diff --git a/src/MongoDB.Bson/Serialization/IBsonSerializationDomain.cs b/src/MongoDB.Bson/Serialization/IBsonSerializationDomain.cs
@@ -298,10 +298,9 @@ void Serialize(
         /// //TODO
         /// </summary>
         IBsonDefaults BsonDefaults { get; }
-    }
 
-    internal interface IBsonSerializationDomainInternal : IBsonSerializationDomain
-    {
+        //DOMAIN-API The following methods and properties were not public on BsonSerializer
+
         void EnsureKnownTypesAreRegistered(Type nominalType);
 
         BsonValue[] GetDiscriminatorsForTypeAndSubTypes(Type type);
diff --git a/src/MongoDB.Bson/Serialization/Serializers/BsonClassMapSerializer.cs b/src/MongoDB.Bson/Serialization/Serializers/BsonClassMapSerializer.cs
@@ -88,7 +88,7 @@ public override TClass Deserialize(BsonDeserializationContext context, BsonDeser
                 return default(TClass);
             }
 
-            var discriminatorConvention = _classMap.GetDiscriminatorConvention(context.SerializationDomain as IBsonSerializationDomainInternal);
+            var discriminatorConvention = _classMap.GetDiscriminatorConvention(context.SerializationDomain);
 
             var actualType = discriminatorConvention.GetActualTypeInternal(bsonReader, args.NominalType, context.SerializationDomain);
 
@@ -147,7 +147,7 @@ public TClass DeserializeClass(BsonDeserializationContext context)
                 }
             }
 
-            var discriminatorConvention = _classMap.GetDiscriminatorConvention(context.SerializationDomain as IBsonSerializationDomainInternal);
+            var discriminatorConvention = _classMap.GetDiscriminatorConvention(context.SerializationDomain);
             var allMemberMaps = _classMap.AllMemberMaps;
             var extraElementsMemberMapIndex = _classMap.ExtraElementsMemberMapIndex;
             var memberMapBitArray = FastMemberMapHelper.GetBitArray(allMemberMaps.Count);
@@ -642,7 +642,7 @@ private void SerializeExtraElements(BsonSerializationContext context, object obj
 
         private void SerializeDiscriminator(BsonSerializationContext context, Type nominalType, object obj)
         {
-            var discriminatorConvention = _classMap.GetDiscriminatorConvention(context.SerializationDomain as IBsonSerializationDomainInternal);
+            var discriminatorConvention = _classMap.GetDiscriminatorConvention(context.SerializationDomain);
             if (discriminatorConvention != null)
             {
                 var actualType = obj.GetType();
diff --git a/src/MongoDB.Bson/Serialization/Serializers/DiscriminatedInterfaceSerializer.cs b/src/MongoDB.Bson/Serialization/Serializers/DiscriminatedInterfaceSerializer.cs
@@ -48,7 +48,7 @@ private static IBsonSerializer<TInterface> CreateInterfaceSerializer(IBsonSerial
             var classMap = (BsonClassMap)Activator.CreateInstance(classMapType);
             classMap.AutoMap();
             classMap.SetDiscriminatorConvention(serializationDomain.LookupDiscriminatorConvention(typeof(TInterface)));
-            classMap.Freeze(serializationDomain as IBsonSerializationDomainInternal);
+            classMap.Freeze(serializationDomain);
             return new BsonClassMapSerializer<TInterface>(classMap);
         }
         #endregion
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/DiscriminatorAstExpression.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/DiscriminatorAstExpression.cs
@@ -16,34 +16,35 @@
 using System;
 using System.Linq;
 using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
 using MongoDB.Bson.Serialization.Conventions;
 using MongoDB.Driver.Linq.Linq3Implementation.Ast.Expressions;
 
 namespace MongoDB.Driver.Linq.Linq3Implementation.Translators;
 
 internal static class DiscriminatorAstExpression
 {
-    public static AstExpression TypeEquals(AstGetFieldExpression discriminatorField, IDiscriminatorConvention discriminatorConvention, Type nominalType, Type actualType)
+    public static AstExpression TypeEquals(AstGetFieldExpression discriminatorField, IDiscriminatorConvention discriminatorConvention, Type nominalType, Type actualType, IBsonSerializationDomain serializationDomain)
     {
-        var discriminator = discriminatorConvention.GetDiscriminator(nominalType, actualType);
+        var discriminator = discriminatorConvention.GetDiscriminatorInternal(nominalType, actualType, serializationDomain);
         return discriminator == null ?
             AstExpression.IsMissing(discriminatorField) :
             AstExpression.Eq(discriminatorField, discriminator);
     }
 
-    public static AstExpression TypeIs(AstGetFieldExpression discriminatorField, IHierarchicalDiscriminatorConvention discriminatorConvention, Type nominalType, Type actualType)
+    public static AstExpression TypeIs(AstGetFieldExpression discriminatorField, IHierarchicalDiscriminatorConvention discriminatorConvention, Type nominalType, Type actualType, IBsonSerializationDomain serializationDomain)
     {
-        var discriminator = discriminatorConvention.GetDiscriminator(nominalType, actualType);
+        var discriminator = discriminatorConvention.GetDiscriminatorInternal(nominalType, actualType, serializationDomain);
         var lastItem = discriminator is BsonArray array ? array.Last() : discriminator;
         return AstExpression.Cond(
             AstExpression.Eq(AstExpression.Type(discriminatorField), "array"),
             AstExpression.In(lastItem, discriminatorField),
             AstExpression.Eq(discriminatorField, lastItem));
     }
 
-    public static AstExpression TypeIs(AstGetFieldExpression discriminatorField, IScalarDiscriminatorConvention discriminatorConvention, Type nominalType, Type actualType)
+    public static AstExpression TypeIs(AstGetFieldExpression discriminatorField, IScalarDiscriminatorConvention discriminatorConvention, Type nominalType, Type actualType, IBsonSerializationDomain serializationDomain)
     {
-        var discriminators = discriminatorConvention.GetDiscriminatorsForTypeAndSubTypes(actualType);
+        var discriminators = discriminatorConvention.GetDiscriminatorsForTypeAndSubTypesInternal(actualType, serializationDomain);
         return discriminators.Length == 1
             ? AstExpression.Eq(discriminatorField, discriminators.Single())
             : AstExpression.In(discriminatorField, new BsonArray(discriminators));
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/GetTypeComparisonExpressionToAggregationExpressionTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/GetTypeComparisonExpressionToAggregationExpressionTranslator.cs
@@ -42,7 +42,7 @@ public static TranslatedExpression Translate(TranslationContext context, BinaryE
 
                 var discriminatorConvention = objectTranslation.Serializer.GetDiscriminatorConvention();
                 var discriminatorField = AstExpression.GetField(objectTranslation.Ast, discriminatorConvention.ElementName);
-                var ast = DiscriminatorAstExpression.TypeEquals(discriminatorField, discriminatorConvention, nominalType, actualType);
+                var ast = DiscriminatorAstExpression.TypeEquals(discriminatorField, discriminatorConvention, nominalType, actualType, context.SerializationDomain);
 
                 return new TranslatedExpression(expression, ast, BooleanSerializer.Instance);
             }
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/OfTypeMethodToAggregationExpressionTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/OfTypeMethodToAggregationExpressionTranslator.cs
@@ -71,8 +71,8 @@ public static TranslatedExpression Translate(TranslationContext context, MethodC
 
                     var ofTypeExpression = discriminatorConvention switch
                     {
-                        IHierarchicalDiscriminatorConvention hierarchicalDiscriminatorConvention => DiscriminatorAstExpression.TypeIs(discriminatorField, hierarchicalDiscriminatorConvention, nominalType, actualType),
-                        IScalarDiscriminatorConvention scalarDiscriminatorConvention => DiscriminatorAstExpression.TypeIs(discriminatorField, scalarDiscriminatorConvention, nominalType, actualType),
+                        IHierarchicalDiscriminatorConvention hierarchicalDiscriminatorConvention => DiscriminatorAstExpression.TypeIs(discriminatorField, hierarchicalDiscriminatorConvention, nominalType, actualType, context.SerializationDomain),
+                        IScalarDiscriminatorConvention scalarDiscriminatorConvention => DiscriminatorAstExpression.TypeIs(discriminatorField, scalarDiscriminatorConvention, nominalType, actualType, context.SerializationDomain),
                         _ => throw new ExpressionNotSupportedException(expression, because: "OfType is not supported with the configured discriminator convention")
                     };
 
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/TypeIsExpressionToAggregationExpressionTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/TypeIsExpressionToAggregationExpressionTranslator.cs
@@ -44,8 +44,8 @@ public static TranslatedExpression Translate(TranslationContext context, TypeBin
 
                 ast = discriminatorConvention switch
                 {
-                    IHierarchicalDiscriminatorConvention hierarchicalDiscriminatorConvention => DiscriminatorAstExpression.TypeIs(discriminatorField, hierarchicalDiscriminatorConvention, nominalType, actualType),
-                    IScalarDiscriminatorConvention scalarDiscriminatorConvention => DiscriminatorAstExpression.TypeIs(discriminatorField, scalarDiscriminatorConvention, nominalType, actualType),
+                    IHierarchicalDiscriminatorConvention hierarchicalDiscriminatorConvention => DiscriminatorAstExpression.TypeIs(discriminatorField, hierarchicalDiscriminatorConvention, nominalType, actualType, context.SerializationDomain),
+                    IScalarDiscriminatorConvention scalarDiscriminatorConvention => DiscriminatorAstExpression.TypeIs(discriminatorField, scalarDiscriminatorConvention, nominalType, actualType, context.SerializationDomain),
                     _ => throw new ExpressionNotSupportedException(expression, because: "is operator is not supported with the configured discriminator convention")
                 };
             }

Original file line number	Diff line number	Diff line change
`@@ -20,9 +20,11 @@`
`20`	`20`
`21`	`21`	`namespace MongoDB.Bson`
`22`	`22`	`{`
`23`		`- //FP This could be moved somewhere else`
	`23`	`+ //FP This could be moved somewhere else, and maybe reordered.`
`24`	`24`	`internal static class InternalExtensions`
`25`	`25`	`{`
	`26`	`+ #region IDiscriminatorConvention`
	`27`	`+`
`26`	`28`	`public static Type GetActualTypeInternal(this IDiscriminatorConvention discriminatorConvention, IBsonReader bsonReader, Type nominalType, IBsonSerializationDomain serializationDomain)`
`27`	`29`	`{`
`28`	`30`	`if (discriminatorConvention is IDiscriminatorConventionInternal internalConvention)`
`@@ -41,6 +43,23 @@ public static BsonValue GetDiscriminatorInternal(this IDiscriminatorConvention d`
`41`	`43`	`return discriminatorConvention.GetDiscriminator(nominalType, actualType);`
`42`	`44`	`}`
`43`	`45`
	`46`	`+ #endregion`
	`47`	`+`
	`48`	`+ #region IScalarDiscriminatorConvention`
	`49`	`+`
	`50`	`+ public static BsonValue[] GetDiscriminatorsForTypeAndSubTypesInternal(this IScalarDiscriminatorConvention discriminatorConvention, Type type, IBsonSerializationDomain serializationDomain)`
	`51`	`+ {`
	`52`	`+ if (discriminatorConvention is IScalarDiscriminatorConventionInternal internalConvention)`
	`53`	`+ {`
	`54`	`+ return internalConvention.GetDiscriminatorsForTypeAndSubTypes(type, serializationDomain);`
	`55`	`+ }`
	`56`	`+ return discriminatorConvention.GetDiscriminatorsForTypeAndSubTypes(type);`
	`57`	`+ }`
	`58`	`+`
	`59`	`+ #endregion`
	`60`	`+`
	`61`	`+ #region IMemberMapConvention`
	`62`	`+`
`44`	`63`	`public static void ApplyInternal(this IMemberMapConvention memberMapConvention, BsonMemberMap memberMap, IBsonSerializationDomain serializationDomain)`
`45`	`64`	`{`
`46`	`65`	`if (memberMapConvention is IMemberMapConventionInternal internalConvention)`
`@@ -53,6 +72,10 @@ public static void ApplyInternal(this IMemberMapConvention memberMapConvention,`
`53`	`72`	`}`
`54`	`73`	`}`
`55`	`74`
	`75`	`+ #endregion`
	`76`	`+`
	`77`	`+ #region IPostProcessingConvention`
	`78`	`+`
`56`	`79`	`public static void PostProcessInternal(this IPostProcessingConvention postProcessingConvention, BsonClassMap classMap, IBsonSerializationDomain serializationDomain)`
`57`	`80`	`{`
`58`	`81`	`if (postProcessingConvention is IPostProcessingConventionInternal internalConvention)`
`@@ -64,5 +87,7 @@ public static void PostProcessInternal(this IPostProcessingConvention postProces`
`64`	`87`	`postProcessingConvention.PostProcess(classMap);`
`65`	`88`	`}`
`66`	`89`	`}`
	`90`	`+`
	`91`	`+ #endregion`
`67`	`92`	`}`
`68`	`93`	`}`
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 IBsonSerializationDomainInternal _serializationDomain;`
	`11`	`+ private readonly IBsonSerializationDomain _serializationDomain;`
`12`	`12`	`private readonly Dictionary<Type, BsonClassMap> _classMaps = new();`
`13`	`13`
`14`	`14`	`public BsonClassMapDomain(BsonSerializationDomain serializationDomain)`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ namespace MongoDB.Bson.Serialization`
`15`	`15`	`/// <summary>`
`16`	`16`	`/// A class that represents the BSON serialization functionality.`
`17`	`17`	`/// </summary>`
`18`		`- internal class BsonSerializationDomain : IBsonSerializationDomainInternal, IDisposable`
	`18`	`+ internal class BsonSerializationDomain : IBsonSerializationDomain, IDisposable`
`19`	`19`	`{`
`20`	`20`	`// private fields`
`21`	`21`	`private IBsonDefaults _bsonDefaults;`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ namespace MongoDB.Bson.Serialization`
`26`	`26`	`/// </summary>`
`27`	`27`	`public static class BsonSerializer`
`28`	`28`	`{`
`29`		`- private static readonly IBsonSerializationDomainInternal _serializationDomain;`
	`29`	`+ private static readonly IBsonSerializationDomain _serializationDomain;`
`30`	`30`
`31`	`31`	`// static constructor`
`32`	`32`	`static BsonSerializer()`
Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,11 @@ public interface IScalarDiscriminatorConvention : IDiscriminatorConvention`
`27`	`27`	`/// </summary>`
`28`	`28`	`/// <param name="type">The type.</param>`
`29`	`29`	`/// <returns>The discriminators.</returns>`
`30`		`- BsonValue[] GetDiscriminatorsForTypeAndSubTypes(Type type); //FP Need to fix this....`
	`30`	`+ BsonValue[] GetDiscriminatorsForTypeAndSubTypes(Type type);`
	`31`	`+ }`
	`32`	`+`
	`33`	`+ internal interface IScalarDiscriminatorConventionInternal : IScalarDiscriminatorConvention`
	`34`	`+ {`
	`35`	`+ BsonValue[] GetDiscriminatorsForTypeAndSubTypes(Type type, IBsonSerializationDomain serializationDomain);`
`31`	`36`	`}`
`32`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ namespace MongoDB.Bson.Serialization.Conventions`
`22`	`22`	`/// <summary>`
`23`	`23`	`/// Represents a discriminator convention where the discriminator is provided by the class map of the actual type.`
`24`	`24`	`/// </summary>`
`25`		`- public class ScalarDiscriminatorConvention : StandardDiscriminatorConvention, IScalarDiscriminatorConvention, IDiscriminatorConventionInternal`
	`25`	`+ public class ScalarDiscriminatorConvention : StandardDiscriminatorConvention, IScalarDiscriminatorConventionInternal, IDiscriminatorConventionInternal`
`26`	`26`	`{`
`27`	`27`	`private readonly ConcurrentDictionary<Type, BsonValue[]> _cachedTypeAndSubTypeDiscriminators = new();`
`28`	`28`
`@@ -67,9 +67,12 @@ BsonValue IDiscriminatorConventionInternal.GetDiscriminator(Type nominalType, Ty`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`/// <inheritdoc/>`
`70`		`- public BsonValue[] GetDiscriminatorsForTypeAndSubTypes(Type type)`
	`70`	`+ public BsonValue[] GetDiscriminatorsForTypeAndSubTypes(Type type) =>`
	`71`	`+ (this as IScalarDiscriminatorConventionInternal).GetDiscriminatorsForTypeAndSubTypes(type, BsonSerializer.DefaultSerializationDomain);`
	`72`	`+`
	`73`	`+ BsonValue[] IScalarDiscriminatorConventionInternal.GetDiscriminatorsForTypeAndSubTypes(Type type, IBsonSerializationDomain serializationDomain)`
`71`	`74`	`{`
`72`		`- return _cachedTypeAndSubTypeDiscriminators.GetOrAdd(type, BsonSerializer.GetDiscriminatorsForTypeAndSubTypes);`
	`75`	`+ return _cachedTypeAndSubTypeDiscriminators.GetOrAdd(type, serializationDomain.GetDiscriminatorsForTypeAndSubTypes);`
`73`	`76`	`}`
`74`	`77`	`}`
`75`	`78`	`}`
Original file line number	Diff line number	Diff line change
`@@ -104,7 +104,7 @@ internal Type GetActualType(IBsonReader bsonReader, Type nominalType, IBsonSeria`
`104`	`104`	`if (bsonType == BsonType.Document)`
`105`	`105`	`{`
`106`	`106`	`// ensure KnownTypes of nominalType are registered (so IsTypeDiscriminated returns correct answer)`
`107`		`- (domain as IBsonSerializationDomainInternal)!.EnsureKnownTypesAreRegistered(nominalType); //TODO Should we move Ensure... to the public interface?`
	`107`	`+ domain.EnsureKnownTypesAreRegistered(nominalType);`
`108`	`108`
`109`	`109`	`// we can skip looking for a discriminator if nominalType has no discriminated sub types`
`110`	`110`	`if (domain.IsTypeDiscriminated(nominalType))`
Original file line number	Diff line number	Diff line change
`@@ -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(context.SerializationDomain as IBsonSerializationDomainInternal);`
	`91`	`+ var discriminatorConvention = _classMap.GetDiscriminatorConvention(context.SerializationDomain);`
`92`	`92`
`93`	`93`	`var actualType = discriminatorConvention.GetActualTypeInternal(bsonReader, args.NominalType, context.SerializationDomain);`
`94`	`94`
`@@ -147,7 +147,7 @@ public TClass DeserializeClass(BsonDeserializationContext context)`
`147`	`147`	`}`
`148`	`148`	`}`
`149`	`149`
`150`		`- var discriminatorConvention = _classMap.GetDiscriminatorConvention(context.SerializationDomain as IBsonSerializationDomainInternal);`
	`150`	`+ var discriminatorConvention = _classMap.GetDiscriminatorConvention(context.SerializationDomain);`
`151`	`151`	`var allMemberMaps = _classMap.AllMemberMaps;`
`152`	`152`	`var extraElementsMemberMapIndex = _classMap.ExtraElementsMemberMapIndex;`
`153`	`153`	`var memberMapBitArray = FastMemberMapHelper.GetBitArray(allMemberMaps.Count);`
`@@ -642,7 +642,7 @@ 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(context.SerializationDomain as IBsonSerializationDomainInternal);`
	`645`	`+ var discriminatorConvention = _classMap.GetDiscriminatorConvention(context.SerializationDomain);`
`646`	`646`	`if (discriminatorConvention != null)`
`647`	`647`	`{`
`648`	`648`	`var actualType = obj.GetType();`