CSHARP-5286: Add IHierarchicalDiscriminatorConvention and IScalarDiscriminatorConvention interfaces.

Author: rstam

src/MongoDB.Bson/Serialization/BsonClassMap.cs

@@ -1093,6 +1093,21 @@ public void SetDiscriminator(string discriminator)
             _discriminator = discriminator;
         }
 
+        /// <summary>
+        /// Sets the discriminator convention.
+        /// </summary>
+        /// <param name="discriminatorConvention">The discriminator convention.</param>
+        public void SetDiscriminatorConvention(IDiscriminatorConvention discriminatorConvention)
+        {
+            if (discriminatorConvention == null)
+            {
+                throw new ArgumentNullException("discriminatorConvention");
+            }
+
+            if (_frozen) { ThrowFrozenException(); }
+            _discriminatorConvention = discriminatorConvention;
+        }
+
         /// <summary>
         /// Sets whether a discriminator is required when serializing this class.
         /// </summary>
@@ -1308,8 +1323,8 @@ internal IDiscriminatorConvention GetDiscriminatorConvention()
             var discriminatorConvention = _discriminatorConvention;
             if (discriminatorConvention == null)
             {
-                // it's possible but harmless for multiple threads to do the initial lookup at the same time
-                discriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(_classType);
+                // it's possible but harmless for multiple threads to do the field initialization at the same time
+                discriminatorConvention = _hasRootClass ? StandardDiscriminatorConvention.Hierarchical : StandardDiscriminatorConvention.Scalar;
                 _discriminatorConvention = discriminatorConvention;
             }
             return discriminatorConvention;

src/MongoDB.Bson/Serialization/BsonSerializer.cs

@@ -398,13 +398,13 @@ public static IDiscriminatorConvention LookupDiscriminatorConvention(Type type)
                     else
                     {
                         // inherit the discriminator convention from the closest parent (that isn't object) that has one
-                        // otherwise default to the standard hierarchical convention
+                        // otherwise default to the standard scalar convention
                         Type parentType = typeInfo.BaseType;
                         while (true)
                         {
                             if (parentType == typeof(object))
                             {
-                                convention = StandardDiscriminatorConvention.Hierarchical;
+                                convention = StandardDiscriminatorConvention.Scalar;
                                 break;
                             }
                             if (__discriminatorConventions.TryGetValue(parentType, out convention))

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
+    public class HierarchicalDiscriminatorConvention : StandardDiscriminatorConvention, IHierarchicalDiscriminatorConvention
     {
         // constructors
         /// <summary>

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

@@ -0,0 +1,24 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace MongoDB.Bson.Serialization.Conventions
+{
+    /// <summary>
+    /// Represents a discriminator convention where the discriminator for each type in a polymorphic hierarchy is an array representing the hierarchy.
+    /// </summary>
+    public interface IHierarchicalDiscriminatorConvention : IDiscriminatorConvention
+    {
+    }
+}

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

@@ -0,0 +1,32 @@
+/* Copyright 2010-present MongoDB Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+using System;
+
+namespace MongoDB.Bson.Serialization.Conventions
+{
+    /// <summary>
+    /// Represents a discriminator convention where the discriminator for each type in a polymorphic hierarchy is a scalar.
+    /// </summary>
+    public interface IScalarDiscriminatorConvention : IDiscriminatorConvention
+    {
+        /// <summary>
+        /// Returns the discriminators for a type and all of its known subtypes.
+        /// </summary>
+        /// <param name="type">The type.</param>
+        /// <returns>The discriminators.</returns>
+        BsonValue[] GetDiscriminatorsForTypeAndSubTypes(Type type);
+    }
+}

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

@@ -43,7 +43,14 @@ public override BsonValue GetDiscriminator(Type nominalType, Type actualType)
         {
             // TODO: this isn't quite right, not all classes are serialized using a class map serializer
             var classMap = BsonClassMap.LookupClassMap(actualType);
-            return classMap.Discriminator;
+            if (actualType != nominalType || classMap.DiscriminatorIsRequired)
+            {
+                return classMap.Discriminator;
+            }
+            else
+            {
+                return null;
+            }
         }
     }
 }

src/MongoDB.Bson/Serialization/IBsonSerializerExtensions.cs

@@ -15,6 +15,7 @@
 
 using System;
 using MongoDB.Bson.IO;
+using MongoDB.Bson.Serialization.Conventions;
 
 namespace MongoDB.Bson.Serialization
 {
@@ -49,6 +50,16 @@ public static TValue Deserialize<TValue>(this IBsonSerializer<TValue> serializer
             return serializer.Deserialize(context, args);
         }
 
+        /// <summary>
+        /// Gets the discriminator convention for a serializer.
+        /// </summary>
+        /// <param name="serializer">The serializer.</param>
+        /// <returns>The discriminator convention.</returns>
+        public static IDiscriminatorConvention GetDiscriminatorConvention(this IBsonSerializer serializer) =>
+            serializer is IHasDiscriminatorConvention hasDiscriminatorConvention
+                ? hasDiscriminatorConvention.DiscriminatorConvention
+                : BsonSerializer.LookupDiscriminatorConvention(serializer.ValueType);
+
         /// <summary>
         /// Serializes a value.
         /// </summary>

src/MongoDB.Bson/Serialization/IHasDiscriminatorConvention.cs

@@ -0,0 +1,30 @@
+/* Copyright 2010-present MongoDB Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+using MongoDB.Bson.Serialization.Conventions;
+
+namespace MongoDB.Bson.Serialization
+{
+    /// <summary>
+    /// Represents a serializer that has a DiscriminatorConvention property.
+    /// </summary>
+    public interface IHasDiscriminatorConvention
+    {
+        /// <summary>
+        /// Gets the discriminator convention.
+        /// </summary>
+        IDiscriminatorConvention DiscriminatorConvention { get; }
+    }
+}

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

@@ -18,6 +18,7 @@
 using System.ComponentModel;
 using System.Reflection;
 using MongoDB.Bson.IO;
+using MongoDB.Bson.Serialization.Conventions;
 using MongoDB.Bson.Serialization.Serializers;
 
 namespace MongoDB.Bson.Serialization
@@ -26,7 +27,7 @@ namespace MongoDB.Bson.Serialization
     /// Represents a serializer for a class map.
     /// </summary>
     /// <typeparam name="TClass">The type of the class.</typeparam>
-    public sealed class BsonClassMapSerializer<TClass> : SerializerBase<TClass>, IBsonIdProvider, IBsonDocumentSerializer, IBsonPolymorphicSerializer
+    public sealed class BsonClassMapSerializer<TClass> : SerializerBase<TClass>, IBsonIdProvider, IBsonDocumentSerializer, IBsonPolymorphicSerializer, IHasDiscriminatorConvention
     {
         // private fields
         private readonly BsonClassMap _classMap;
@@ -56,6 +57,9 @@ public BsonClassMapSerializer(BsonClassMap classMap)
         }
 
         // public properties
+        /// <inheritdoc/>
+        public IDiscriminatorConvention DiscriminatorConvention => _classMap.GetDiscriminatorConvention();
+
         /// <summary>
         /// Gets a value indicating whether this serializer's discriminator is compatible with the object serializer.
         /// </summary>

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

@@ -100,7 +100,7 @@ protected virtual TValue DeserializeValue(BsonDeserializationContext context, Bs
         /// <returns>The actual type.</returns>
         protected virtual Type GetActualType(BsonDeserializationContext context)
         {
-            var discriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(typeof(TValue));
+            var discriminatorConvention = this.GetDiscriminatorConvention();
             return discriminatorConvention.GetActualType(context.Reader, typeof(TValue));
         }