Fixed discriminator method

Author: papafe

src/MongoDB.Bson/Serialization/BsonClassMap.cs

@@ -117,6 +117,14 @@ public IEnumerable<BsonCreatorMap> CreatorMaps
             get { return _creatorMaps; }
         }
 
+        /// <summary>
+        /// Gets the conventions used for auto mapping.
+        /// </summary>
+        public IConventionPack ConventionPack
+        {
+            get { return BsonSerializer.DefaultSerializationDomain.ConventionRegistry.Lookup(_classType); }  //TODO This is not completely correct, this should be eliminated.
+        }
+
         /// <summary>
         /// Gets the declared member maps (only for members declared in this class).
         /// </summary>

src/MongoDB.Bson/Serialization/Conventions/HierarchicalDiscriminatorConvention.cs

@@ -22,7 +22,7 @@ namespace MongoDB.Bson.Serialization.Conventions
     /// <summary>
     /// Represents a discriminator convention where the discriminator is an array of all the discriminators provided by the class maps of the root class down to the actual type.
     /// </summary>
-    public class HierarchicalDiscriminatorConvention : StandardDiscriminatorConvention, IHierarchicalDiscriminatorConvention
+    public class HierarchicalDiscriminatorConvention : StandardDiscriminatorConvention, IHierarchicalDiscriminatorConvention, IDiscriminatorConventionInternal
     {
         // constructors
         /// <summary>
@@ -45,7 +45,7 @@ public override BsonValue GetDiscriminator(Type nominalType, Type actualType) =>
             GetDiscriminator(nominalType, actualType, BsonSerializer.DefaultSerializationDomain);
 
         /// <inheritdoc />
-        public override BsonValue GetDiscriminator(Type nominalType, Type actualType, IBsonSerializationDomain domain)
+        public BsonValue GetDiscriminator(Type nominalType, Type actualType, IBsonSerializationDomain domain)
         {
             // TODO: this isn't quite right, not all classes are serialized using  a class map serializer
             var classMap = domain.BsonClassMap.LookupClassMap(actualType);

src/MongoDB.Bson/Serialization/Conventions/IDiscriminatorConvention.cs

@@ -36,6 +36,17 @@ public interface IDiscriminatorConvention
         /// <returns>The actual type.</returns>
         Type GetActualType(IBsonReader bsonReader, Type nominalType);
 
+        /// <summary>
+        /// Gets the discriminator value for an actual type.
+        /// </summary>
+        /// <param name="nominalType">The nominal type.</param>
+        /// <param name="actualType">The actual type.</param>
+        /// <returns>The discriminator value.</returns>
+        BsonValue GetDiscriminator(Type nominalType, Type actualType);
+    }
+
+    internal interface IDiscriminatorConventionInternal : IDiscriminatorConvention
+    {
         /// <summary>
         /// //TODO
         /// </summary>
@@ -45,14 +56,6 @@ public interface IDiscriminatorConvention
         /// <returns></returns>
         Type GetActualType(IBsonReader bsonReader, Type nominalType, IBsonSerializationDomain domain);
 
-        /// <summary>
-        /// Gets the discriminator value for an actual type.
-        /// </summary>
-        /// <param name="nominalType">The nominal type.</param>
-        /// <param name="actualType">The actual type.</param>
-        /// <returns>The discriminator value.</returns>
-        BsonValue GetDiscriminator(Type nominalType, Type actualType);
-
         /// <summary>
         /// //TODO
         /// </summary>

src/MongoDB.Bson/Serialization/Conventions/ScalarDiscriminatorConvention.cs

@@ -21,7 +21,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
+    public class ScalarDiscriminatorConvention : StandardDiscriminatorConvention, IScalarDiscriminatorConvention, IDiscriminatorConventionInternal
     {
         private readonly ConcurrentDictionary<Type, BsonValue[]> _cachedTypeAndSubTypeDiscriminators = new();
 
@@ -46,7 +46,7 @@ public override BsonValue GetDiscriminator(Type nominalType, Type actualType) =>
             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)
+        public BsonValue GetDiscriminator(Type nominalType, Type actualType, IBsonSerializationDomain domain)
         {
             // TODO: this isn't quite right, not all classes are serialized using a class map serializer
             var classMap = domain.BsonClassMap.LookupClassMap(actualType);

src/MongoDB.Bson/Serialization/Conventions/StandardDiscriminatorConvention.cs

@@ -95,10 +95,11 @@ obj is StandardDiscriminatorConvention other &&
         /// <param name="bsonReader">The reader.</param>
         /// <param name="nominalType">The nominal type.</param>
         /// <returns>The actual type.</returns>
-        public Type GetActualType(IBsonReader bsonReader, Type nominalType) =>
+        public Type GetActualType(IBsonReader bsonReader, Type nominalType) =>  //TODO This one should not be used
             GetActualType(bsonReader, nominalType, BsonSerializer.DefaultSerializationDomain);
 
         /// <inheritdoc />
+        /// TODO
         public Type GetActualType(IBsonReader bsonReader, Type nominalType, IBsonSerializationDomain domain)
         {
             // the BsonReader is sitting at the value whose actual type needs to be found
@@ -140,9 +141,6 @@ public Type GetActualType(IBsonReader bsonReader, Type nominalType, IBsonSeriali
         /// <returns>The discriminator value.</returns>
         public abstract BsonValue GetDiscriminator(Type nominalType, Type actualType);
 
-        /// <inheritdoc/>
-        public abstract BsonValue GetDiscriminator(Type nominalType, Type actualType, IBsonSerializationDomain domain);
-
         /// <inheritdoc/>
         public override int GetHashCode() => 0;
     }

src/MongoDB.Bson/Serialization/Serializers/BsonClassMapSerializer.cs

@@ -90,7 +90,17 @@ public override TClass Deserialize(BsonDeserializationContext context, BsonDeser
 
             var discriminatorConvention = _classMap.GetDiscriminatorConvention(context.SerializationDomain as IBsonSerializationDomainInternal);
 
-            var actualType = discriminatorConvention.GetActualType(bsonReader, args.NominalType);
+            Type actualType;
+
+            if (discriminatorConvention is IDiscriminatorConventionInternal discriminatorConventionInternal)
+            {
+                actualType = discriminatorConventionInternal.GetActualType(bsonReader, args.NominalType, context.SerializationDomain);
+            }
+            else
+            {
+                actualType = discriminatorConvention.GetActualType(bsonReader, args.NominalType);
+            }
+
             if (actualType == typeof(TClass))
             {
                 return DeserializeClass(context);
@@ -646,7 +656,17 @@ private void SerializeDiscriminator(BsonSerializationContext context, Type nomin
             if (discriminatorConvention != null)
             {
                 var actualType = obj.GetType();
-                var discriminator = discriminatorConvention.GetDiscriminator(nominalType, actualType, context.SerializationDomain);
+
+                BsonValue discriminator;
+                if (discriminatorConvention is IDiscriminatorConventionInternal discriminatorConventionInternal)
+                {
+                    discriminator = discriminatorConventionInternal.GetDiscriminator(nominalType, actualType, context.SerializationDomain);
+                }
+                else
+                {
+                    discriminator = discriminatorConvention.GetDiscriminator(nominalType, actualType);
+                }
+
                 if (discriminator != null)
                 {
                     context.Writer.WriteName(discriminatorConvention.ElementName);

src/MongoDB.Bson/Serialization/Serializers/ObjectSerializer.cs

@@ -364,7 +364,17 @@ private object DeserializeDiscriminatedValue(BsonDeserializationContext context,
         {
             var bsonReader = context.Reader;
 
-            var actualType = _discriminatorConvention.GetActualType(bsonReader, typeof(object));
+            Type actualType;
+
+            if (_discriminatorConvention is IDiscriminatorConventionInternal discriminatorConventionInternal)
+            {
+                actualType = discriminatorConventionInternal.GetActualType(bsonReader, args.NominalType, context.SerializationDomain);  //TODO I think these type of things could become an internal extension methods
+            }
+            else
+            {
+                actualType = _discriminatorConvention.GetActualType(bsonReader, args.NominalType);
+            }
+
             if (!_allowedDeserializationTypes(actualType))
             {
                 throw new BsonSerializationException($"Type {actualType.FullName} is not configured as a type that is allowed to be deserialized for this instance of ObjectSerializer.");

tests/MongoDB.Bson.Tests/Serialization/Conventions/StandardDiscriminatorConventionTests.cs

@@ -117,10 +117,6 @@ public ConcreteStandardDiscriminatorConvention(string elementName)
             }
 
             public override BsonValue GetDiscriminator(Type nominalType, Type actualType) => throw new NotImplementedException();
-            public override BsonValue GetDiscriminator(Type nominalType, Type actualType, IBsonSerializationDomain domain)
-            {
-                throw new NotImplementedException();
-            }
         }
 
         public class DerivedFromConcreteStandardDiscriminatorConvention : ConcreteStandardDiscriminatorConvention