Fix for getDicriminatorConvention and IBsonIdProvider

Author: papafe

src/MongoDB.Bson/InternalExtensions.cs

@@ -23,6 +23,20 @@ namespace MongoDB.Bson
     //FP This could be moved somewhere else, and maybe reordered.
     internal static class InternalExtensions
     {
+        #region IBsonIdProvider
+
+        public static bool GetDocumentIdInternal(this IBsonIdProvider provider, object document, IBsonSerializationDomain serializationDomain, out object id,
+            out Type idNominalType, out IIdGenerator idGenerator)
+        {
+            if (provider is IBsonIdProviderInternal internalProvider)
+            {
+                return internalProvider.GetDocumentId(document, serializationDomain, out id, out idNominalType, out idGenerator);
+            }
+            return provider.GetDocumentId(document, out id, out idNominalType, out idGenerator);
+        }
+
+        #endregion
+
         #region IDiscriminatorConvention
 
         public static Type GetActualTypeInternal(this IDiscriminatorConvention discriminatorConvention, IBsonReader bsonReader, Type nominalType, IBsonSerializationDomain serializationDomain)

src/MongoDB.Bson/Serialization/BsonSerializationProviderBase.cs

@@ -23,15 +23,17 @@ namespace MongoDB.Bson.Serialization
     /// </summary>
     public abstract class BsonSerializationProviderBase : IRegistryAwareBsonSerializationProvider
     {
+        //DOMAIN-API We should remove this and use the overload that takes a serializer registry instead.
         /// <inheritdoc/>
         public virtual IBsonSerializer GetSerializer(Type type)
         {
-            return GetSerializer(type, BsonSerializer.DefaultSerializationDomain.SerializerRegistry);   //TODO We can keep this as is? I think in the long run we should remove this overload.
+            return GetSerializer(type, BsonSerializer.DefaultSerializationDomain.SerializerRegistry);
         }
 
         /// <inheritdoc/>
         public abstract IBsonSerializer GetSerializer(Type type, IBsonSerializerRegistry serializerRegistry);
 
+        //DOMAIN-API We should remove this and use the overload that takes a serializer registry instead.
         /// <summary>
         /// Creates the serializer from a serializer type definition and type arguments.
         /// </summary>
@@ -40,7 +42,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.DefaultSerializationDomain.SerializerRegistry);   //TODO We can keep this as is? I think in the long run we should remove this overload.
+            return CreateGenericSerializer(serializerTypeDefinition, typeArguments, BsonSerializer.DefaultSerializationDomain.SerializerRegistry);
         }
 
         /// <summary>
@@ -58,14 +60,15 @@ protected virtual IBsonSerializer CreateGenericSerializer(Type serializerTypeDef
             return CreateSerializer(serializerType, serializerRegistry);
         }
 
+        //DOMAIN-API We should remove this and use the overload that takes a serializer registry instead.
         /// <summary>
         /// Creates the serializer.
         /// </summary>
         /// <param name="serializerType">The serializer type.</param>
         /// <returns>A serializer.</returns>
         protected virtual IBsonSerializer CreateSerializer(Type serializerType)
         {
-            return CreateSerializer(serializerType, BsonSerializer.SerializerRegistry);   //TODO We can keep this as is? I think in the long run we should remove this overload.
+            return CreateSerializer(serializerType, BsonSerializer.SerializerRegistry);
         }
 
         /// <summary>

src/MongoDB.Bson/Serialization/IBsonIdProvider.cs

@@ -42,15 +42,6 @@ public interface IBsonIdProvider
 
     internal interface IBsonIdProviderInternal : IBsonIdProvider
     {
-        /// <summary>
-        /// //TODO
-        /// </summary>
-        /// <param name="document"></param>
-        /// <param name="serializationDomain"></param>
-        /// <param name="id"></param>
-        /// <param name="idNominalType"></param>
-        /// <param name="idGenerator"></param>
-        /// <returns></returns>
         bool GetDocumentId(object document, IBsonSerializationDomain serializationDomain, out object id, out Type idNominalType, out IIdGenerator idGenerator);
     }
 }

src/MongoDB.Bson/Serialization/IBsonSerializationProvider.cs

@@ -17,6 +17,7 @@
 
 namespace MongoDB.Bson.Serialization
 {
+    //DOMAIN-API We should remove this interface and merge it with IRegistryAwareBsonSerializationProvider.
     /// <summary>
     /// An interface implemented by serialization providers.
     /// </summary>

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

@@ -109,12 +109,12 @@ public DiscriminatedInterfaceSerializer(IDiscriminatorConvention discriminatorCo
             }
 
             _interfaceType = typeof(TInterface);
-            _discriminatorConvention = discriminatorConvention ?? interfaceSerializer.GetDiscriminatorConvention();
+            _discriminatorConvention = discriminatorConvention ?? interfaceSerializer.GetDiscriminatorConvention(); //QUESTION What do we do here? We don't have the domain close by, should we lazy initialize it during serialization/deserialization?
             _interfaceSerializer = interfaceSerializer;
 
             if (objectSerializer == null)
             {
-                objectSerializer = BsonSerializer.LookupSerializer<object>();  //TODO What do we do here?
+                objectSerializer = BsonSerializer.LookupSerializer<object>();  //QUESTION What do we do here? We don't have the domain close by, should we lazy initialize it during serialization/deserialization?
                 if (objectSerializer is ObjectSerializer standardObjectSerializer)
                 {
                     Func<Type, bool> allowedTypes = (Type type) => typeof(TInterface).IsAssignableFrom(type);

src/MongoDB.Driver/BsonSerializerExtensions.cs

@@ -13,20 +13,21 @@
 * limitations under the License.
 */
 
+using MongoDB.Bson;
 using MongoDB.Bson.Serialization;
 
 namespace MongoDB.Driver
 {
     internal static class BsonSerializerExtensions
     {
-        public static object SetDocumentIdIfMissing<TDocument>(this IBsonSerializer<TDocument> serializer, object container, TDocument document)
+        public static object SetDocumentIdIfMissing<TDocument>(this IBsonSerializer<TDocument> serializer, object container, TDocument document, IBsonSerializationDomain serializationDomain)
         {
             var idProvider = serializer as IBsonIdProvider;
             if (idProvider != null)
             {
                 object id;
                 IIdGenerator idGenerator;
-                if (idProvider.GetDocumentId(document, out id, out _, out idGenerator))
+                if (idProvider.GetDocumentIdInternal(document, serializationDomain, out id, out _, out idGenerator))
                 {
                     if (idGenerator != null && idGenerator.IsEmpty(id))
                     {

src/MongoDB.Driver/Core/WireProtocol/Messages/Encoders/BinaryEncoders/ClientBulkWriteOpsSectionFormatter.cs

@@ -149,7 +149,7 @@ public void RenderInsertOne<TDocument>(RenderArgs<BsonDocument> renderArgs, Bson
         {
             WriteStartModel(serializationContext, "insert", model);
             var documentSerializer = _serializerRegistry.GetSerializer<TDocument>();
-            var documentId = documentSerializer.SetDocumentIdIfMissing(null, model.Document);
+            var documentId = documentSerializer.SetDocumentIdIfMissing(null, model.Document, serializationContext.SerializationDomain);
             _idsMap[_currentIndex] = BsonValue.Create(documentId);
             serializationContext.Writer.WriteName("document");
             documentSerializer.Serialize(serializationContext, model.Document);

src/MongoDB.Driver/FilterDefinitionBuilder.cs

@@ -2205,7 +2205,7 @@ public override BsonDocument Render(RenderArgs<TDocument> args)
             }
             else
             {
-                var discriminatorConvention = args.DocumentSerializer.GetDiscriminatorConvention();
+                var discriminatorConvention = args.DocumentSerializer.GetDiscriminatorConvention(args.SerializationDomain);
                 if (discriminatorConvention == null)
                 {
                     var message = string.Format("OfType requires a discriminator convention for type: {0}.", BsonUtils.GetFriendlyTypeName(typeof(TDocument)));
@@ -2268,7 +2268,7 @@ public override BsonDocument Render(RenderArgs<TDocument> args)
             }
             else
             {
-                var discriminatorConvention = renderedField.FieldSerializer.GetDiscriminatorConvention();
+                var discriminatorConvention = renderedField.FieldSerializer.GetDiscriminatorConvention(args.SerializationDomain);
                 if (discriminatorConvention == null)
                 {
                     var message = string.Format("OfType requires a discriminator convention for type: {0}.", BsonUtils.GetFriendlyTypeName(typeof(TField)));

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/GetTypeComparisonExpressionToAggregationExpressionTranslator.cs

@@ -40,7 +40,7 @@ public static TranslatedExpression Translate(TranslationContext context, BinaryE
                 var nominalType = objectExpression.Type;
                 var actualType = comparandType;
 
-                var discriminatorConvention = objectTranslation.Serializer.GetDiscriminatorConvention();
+                var discriminatorConvention = objectTranslation.Serializer.GetDiscriminatorConvention(context.SerializationDomain);
                 var discriminatorField = AstExpression.GetField(objectTranslation.Ast, discriminatorConvention.ElementName);
                 var ast = DiscriminatorAstExpression.TypeEquals(discriminatorField, discriminatorConvention, nominalType, actualType, context.SerializationDomain);
 

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/OfTypeMethodToAggregationExpressionTranslator.cs

@@ -65,7 +65,7 @@ public static TranslatedExpression Translate(TranslationContext context, MethodC
                 }
                 else
                 {
-                    var discriminatorConvention = nominalTypeSerializer.GetDiscriminatorConvention();
+                    var discriminatorConvention = nominalTypeSerializer.GetDiscriminatorConvention(context.SerializationDomain);
                     var itemVar = AstExpression.Var("item");
                     var discriminatorField = AstExpression.GetField(itemVar, discriminatorConvention.ElementName);