Merged IBsonSerializationDomainInternal into IBsonSerializationDomain and created GetDiscriminatorsForTypeAndSubTypesInternal.

Author: papafe

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
     }
 }

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)

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)

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;

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()

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);
     }
 }

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);
         }
     }
 }

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))

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);

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();