Fix for getDicriminatorConvention and IBsonIdProvider

papafe · papafe · commit 530328e791c0 · 2025-06-28T11:38:14.000+02:00
diff --git a/src/MongoDB.Bson/InternalExtensions.cs b/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)
diff --git a/src/MongoDB.Bson/Serialization/BsonSerializationProviderBase.cs b/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>
diff --git a/src/MongoDB.Bson/Serialization/IBsonIdProvider.cs b/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);
     }
 }
diff --git a/src/MongoDB.Bson/Serialization/IBsonSerializationProvider.cs b/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>
diff --git a/src/MongoDB.Bson/Serialization/Serializers/DiscriminatedInterfaceSerializer.cs b/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);
diff --git a/src/MongoDB.Driver/BsonSerializerExtensions.cs b/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))
                     {
diff --git a/src/MongoDB.Driver/Core/WireProtocol/Messages/Encoders/BinaryEncoders/ClientBulkWriteOpsSectionFormatter.cs b/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);
diff --git a/src/MongoDB.Driver/FilterDefinitionBuilder.cs b/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)));
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/GetTypeComparisonExpressionToAggregationExpressionTranslator.cs b/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);
 
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/OfTypeMethodToAggregationExpressionTranslator.cs b/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);
 
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/ExpressionTranslators/GetTypeComparisonExpressionToFilterTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/ExpressionTranslators/GetTypeComparisonExpressionToFilterTranslator.cs
@@ -55,7 +55,7 @@ public static AstFilter Translate(
                 var nominalType = fieldTranslation.Serializer.ValueType;
                 var actualType = typeConstantExpression.GetConstantValue<Type>(expression);
 
-                var discriminatorConvention = fieldTranslation.Serializer.GetDiscriminatorConvention();
+                var discriminatorConvention = fieldTranslation.Serializer.GetDiscriminatorConvention(context.SerializationDomain);
                 var discriminatorField = fieldTranslation.Ast.SubField(discriminatorConvention.ElementName);
 
                 var filter = discriminatorConvention switch
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/ExpressionTranslators/TypeIsExpressionToFilterTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/ExpressionTranslators/TypeIsExpressionToFilterTranslator.cs
@@ -41,7 +41,7 @@ public static AstFilter Translate(TranslationContext context, TypeBinaryExpressi
                 }
                 else
                 {
-                    var discriminatorConvention = fieldTranslation.Serializer.GetDiscriminatorConvention();
+                    var discriminatorConvention = fieldTranslation.Serializer.GetDiscriminatorConvention(context.SerializationDomain);
                     var discriminatorField = fieldTranslation.Ast.SubField(discriminatorConvention.ElementName);
 
                     return discriminatorConvention switch
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/MethodTranslators/AllOrAnyMethodToFilterTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/MethodTranslators/AllOrAnyMethodToFilterTranslator.cs
@@ -120,7 +120,7 @@ public static (TranslatedFilterField, AstFilter) Translate(TranslationContext co
                     var sourceSerializer = fieldTranslation.Serializer;
                     var itemSerializer = ArraySerializerHelper.GetItemSerializer(sourceSerializer);
 
-                    var discriminatorConvention = itemSerializer.GetDiscriminatorConvention();
+                    var discriminatorConvention = itemSerializer.GetDiscriminatorConvention(context.SerializationDomain);
                     var discriminatorField = AstFilter.Field(discriminatorConvention.ElementName);
 
                     var ofTypeFilter = discriminatorConvention switch
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToPipelineTranslators/OfTypeMethodToPipelineTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToPipelineTranslators/OfTypeMethodToPipelineTranslator.cs
@@ -51,12 +51,12 @@ public static TranslatedPipeline Translate(TranslationContext context, MethodCal
                     return pipeline;
                 }
 
-                var discriminatorConvention = pipeline.OutputSerializer.GetDiscriminatorConvention();
+                var discriminatorConvention = pipeline.OutputSerializer.GetDiscriminatorConvention(context.SerializationDomain);
                 var discriminatorElementName = discriminatorConvention.ElementName;
                 var wrappedValueOutputSerializer = pipeline.OutputSerializer as IWrappedValueSerializer;
                 if (wrappedValueOutputSerializer != null)
                 {
-                    discriminatorConvention = wrappedValueOutputSerializer.ValueSerializer.GetDiscriminatorConvention();
+                    discriminatorConvention = wrappedValueOutputSerializer.ValueSerializer.GetDiscriminatorConvention(context.SerializationDomain);
                     discriminatorElementName = wrappedValueOutputSerializer.FieldName + "." + discriminatorElementName;
                 }
                 var discriminatorField = AstFilter.Field(discriminatorElementName);
diff --git a/src/MongoDB.Driver/MongoCollectionImpl.cs b/src/MongoDB.Driver/MongoCollectionImpl.cs
@@ -754,7 +754,7 @@ private WriteRequest ConvertWriteModelToWriteRequest(WriteModel<TDocument> model
                     var insertOneModel = (InsertOneModel<TDocument>)model;
                     if (_settings.AssignIdOnInsert)
                     {
-                        _documentSerializer.SetDocumentIdIfMissing(this, insertOneModel.Document);
+                        _documentSerializer.SetDocumentIdIfMissing(this, insertOneModel.Document, renderArgs.SerializationDomain);
                     }
                     return new InsertRequest(new BsonDocumentWrapper(insertOneModel.Document, _documentSerializer))
                     {
diff --git a/src/MongoDB.Driver/OfTypeMongoCollection.cs b/src/MongoDB.Driver/OfTypeMongoCollection.cs
@@ -61,7 +61,7 @@ protected override UpdateDefinition<TDerivedDocument> AdjustUpdateDefinition(Upd
 
             if (isUpsert)
             {
-                var discriminatorConvention = _rootDocumentCollection.DocumentSerializer.GetDiscriminatorConvention();
+                var discriminatorConvention = _rootDocumentCollection.DocumentSerializer.GetDiscriminatorConvention(Settings.SerializationDomain);
                 var discriminatorConventionElementName = discriminatorConvention.ElementName;
                 var discriminator = discriminatorConvention.GetDiscriminatorInternal(typeof(TRootDocument), typeof(TDerivedDocument), Settings.SerializationDomain);
 
diff --git a/src/MongoDB.Driver/OfTypeSerializer.cs b/src/MongoDB.Driver/OfTypeSerializer.cs
@@ -14,12 +14,13 @@
 */
 
 using System;
+using MongoDB.Bson;
 using MongoDB.Bson.Serialization;
 using MongoDB.Bson.Serialization.Serializers;
 
 namespace MongoDB.Driver
 {
-    internal sealed class OfTypeSerializer<TRootDocument, TDerivedDocument> : SerializerBase<TDerivedDocument>, IBsonDocumentSerializer, IBsonIdProvider
+    internal sealed class OfTypeSerializer<TRootDocument, TDerivedDocument> : SerializerBase<TDerivedDocument>, IBsonDocumentSerializer, IBsonIdProviderInternal
         where TDerivedDocument : TRootDocument
     {
         private readonly IBsonSerializer<TDerivedDocument> _derivedDocumentSerializer;
@@ -45,21 +46,24 @@ obj is OfTypeSerializer<TRootDocument, TDerivedDocument> other &&
                 object.Equals(_derivedDocumentSerializer, other._derivedDocumentSerializer);
         }
 
-        public bool
-            GetDocumentId(object document, out object id, out Type idNominalType, out IIdGenerator idGenerator)
+        public bool GetDocumentId(object document, out object id, out Type idNominalType, out IIdGenerator idGenerator)
+            => GetDocumentId(document, BsonSerializer.DefaultSerializationDomain, out id, out idNominalType, out idGenerator);
+
+        public bool GetDocumentId(object document, IBsonSerializationDomain serializationDomain, out object id, out Type idNominalType,
+            out IIdGenerator idGenerator)
+        {
+            if (_derivedDocumentSerializer is IBsonIdProvider idProvider)
             {
-                if (_derivedDocumentSerializer is IBsonIdProvider idProvider)
-                {
-                    return idProvider.GetDocumentId(document, out id, out idNominalType, out idGenerator);
-                }
-                else
-                {
-                    id = null;
-                    idNominalType = null;
-                    idGenerator = null;
-                    return false;
-                }
+                return idProvider.GetDocumentIdInternal(document, serializationDomain, out id, out idNominalType, out idGenerator);
             }
+            else
+            {
+                id = null;
+                idNominalType = null;
+                idGenerator = null;
+                return false;
+            }
+        }
 
         public override int GetHashCode() => 0;
 
diff --git a/src/MongoDB.Driver/PipelineStageDefinitionBuilder.cs b/src/MongoDB.Driver/PipelineStageDefinitionBuilder.cs
@@ -1280,7 +1280,7 @@ public static PipelineStageDefinition<TInput, TOutput> OfType<TInput, TOutput>(
                     else
                     {
                         var inputSerializer = args.DocumentSerializer;
-                        var discriminatorConvention = inputSerializer.GetDiscriminatorConvention();
+                        var discriminatorConvention = inputSerializer.GetDiscriminatorConvention(args.SerializationDomain);
                         if (discriminatorConvention == null)
                         {
                             var message = string.Format("OfType requires that a discriminator convention exist for type: {0}.", BsonUtils.GetFriendlyTypeName(typeof(TOutput)));

Original file line number	Diff line number	Diff line change
`@@ -23,15 +23,17 @@ namespace MongoDB.Bson.Serialization`
`23`	`23`	`/// </summary>`
`24`	`24`	`public abstract class BsonSerializationProviderBase : IRegistryAwareBsonSerializationProvider`
`25`	`25`	`{`
	`26`	`+ //DOMAIN-API We should remove this and use the overload that takes a serializer registry instead.`
`26`	`27`	`/// <inheritdoc/>`
`27`	`28`	`public virtual IBsonSerializer GetSerializer(Type type)`
`28`	`29`	`{`
`29`		`- return GetSerializer(type, BsonSerializer.DefaultSerializationDomain.SerializerRegistry); //TODO We can keep this as is? I think in the long run we should remove this overload.`
	`30`	`+ return GetSerializer(type, BsonSerializer.DefaultSerializationDomain.SerializerRegistry);`
`30`	`31`	`}`
`31`	`32`
`32`	`33`	`/// <inheritdoc/>`
`33`	`34`	`public abstract IBsonSerializer GetSerializer(Type type, IBsonSerializerRegistry serializerRegistry);`
`34`	`35`
	`36`	`+ //DOMAIN-API We should remove this and use the overload that takes a serializer registry instead.`
`35`	`37`	`/// <summary>`
`36`	`38`	`/// Creates the serializer from a serializer type definition and type arguments.`
`37`	`39`	`/// </summary>`
`@@ -40,7 +42,7 @@ public virtual IBsonSerializer GetSerializer(Type type)`
`40`	`42`	`/// <returns>A serializer.</returns>`
`41`	`43`	`protected virtual IBsonSerializer CreateGenericSerializer(Type serializerTypeDefinition, params Type[] typeArguments)`
`42`	`44`	`{`
`43`		`- 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.`
	`45`	`+ return CreateGenericSerializer(serializerTypeDefinition, typeArguments, BsonSerializer.DefaultSerializationDomain.SerializerRegistry);`
`44`	`46`	`}`
`45`	`47`
`46`	`48`	`/// <summary>`
`@@ -58,14 +60,15 @@ protected virtual IBsonSerializer CreateGenericSerializer(Type serializerTypeDef`
`58`	`60`	`return CreateSerializer(serializerType, serializerRegistry);`
`59`	`61`	`}`
`60`	`62`
	`63`	`+ //DOMAIN-API We should remove this and use the overload that takes a serializer registry instead.`
`61`	`64`	`/// <summary>`
`62`	`65`	`/// Creates the serializer.`
`63`	`66`	`/// </summary>`
`64`	`67`	`/// <param name="serializerType">The serializer type.</param>`
`65`	`68`	`/// <returns>A serializer.</returns>`
`66`	`69`	`protected virtual IBsonSerializer CreateSerializer(Type serializerType)`
`67`	`70`	`{`
`68`		`- return CreateSerializer(serializerType, BsonSerializer.SerializerRegistry); //TODO We can keep this as is? I think in the long run we should remove this overload.`
	`71`	`+ return CreateSerializer(serializerType, BsonSerializer.SerializerRegistry);`
`69`	`72`	`}`
`70`	`73`
`71`	`74`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -42,15 +42,6 @@ public interface IBsonIdProvider`
`42`	`42`
`43`	`43`	`internal interface IBsonIdProviderInternal : IBsonIdProvider`
`44`	`44`	`{`
`45`		`- /// <summary>`
`46`		`- /// //TODO`
`47`		`- /// </summary>`
`48`		`- /// <param name="document"></param>`
`49`		`- /// <param name="serializationDomain"></param>`
`50`		`- /// <param name="id"></param>`
`51`		`- /// <param name="idNominalType"></param>`
`52`		`- /// <param name="idGenerator"></param>`
`53`		`- /// <returns></returns>`
`54`	`45`	`bool GetDocumentId(object document, IBsonSerializationDomain serializationDomain, out object id, out Type idNominalType, out IIdGenerator idGenerator);`
`55`	`46`	`}`
`56`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,7 @@`
`17`	`17`
`18`	`18`	`namespace MongoDB.Bson.Serialization`
`19`	`19`	`{`
	`20`	`+ //DOMAIN-API We should remove this interface and merge it with IRegistryAwareBsonSerializationProvider.`
`20`	`21`	`/// <summary>`
`21`	`22`	`/// An interface implemented by serialization providers.`
`22`	`23`	`/// </summary>`
Original file line number	Diff line number	Diff line change
`@@ -109,12 +109,12 @@ public DiscriminatedInterfaceSerializer(IDiscriminatorConvention discriminatorCo`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`_interfaceType = typeof(TInterface);`
`112`		`- _discriminatorConvention = discriminatorConvention ?? interfaceSerializer.GetDiscriminatorConvention();`
	`112`	`+ _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?`
`113`	`113`	`_interfaceSerializer = interfaceSerializer;`
`114`	`114`
`115`	`115`	`if (objectSerializer == null)`
`116`	`116`	`{`
`117`		`- objectSerializer = BsonSerializer.LookupSerializer<object>(); //TODO What do we do here?`
	`117`	`+ 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?`
`118`	`118`	`if (objectSerializer is ObjectSerializer standardObjectSerializer)`
`119`	`119`	`{`
`120`	`120`	`Func<Type, bool> allowedTypes = (Type type) => typeof(TInterface).IsAssignableFrom(type);`
Original file line number	Diff line number	Diff line change
`@@ -13,20 +13,21 @@`
`13`	`13`	`* limitations under the License.`
`14`	`14`	`*/`
`15`	`15`
	`16`	`+using MongoDB.Bson;`
`16`	`17`	`using MongoDB.Bson.Serialization;`
`17`	`18`
`18`	`19`	`namespace MongoDB.Driver`
`19`	`20`	`{`
`20`	`21`	`internal static class BsonSerializerExtensions`
`21`	`22`	`{`
`22`		`- public static object SetDocumentIdIfMissing<TDocument>(this IBsonSerializer<TDocument> serializer, object container, TDocument document)`
	`23`	`+ public static object SetDocumentIdIfMissing<TDocument>(this IBsonSerializer<TDocument> serializer, object container, TDocument document, IBsonSerializationDomain serializationDomain)`
`23`	`24`	`{`
`24`	`25`	`var idProvider = serializer as IBsonIdProvider;`
`25`	`26`	`if (idProvider != null)`
`26`	`27`	`{`
`27`	`28`	`object id;`
`28`	`29`	`IIdGenerator idGenerator;`
`29`		`- if (idProvider.GetDocumentId(document, out id, out _, out idGenerator))`
	`30`	`+ if (idProvider.GetDocumentIdInternal(document, serializationDomain, out id, out _, out idGenerator))`
`30`	`31`	`{`
`31`	`32`	`if (idGenerator != null && idGenerator.IsEmpty(id))`
`32`	`33`	`{`
Original file line number	Diff line number	Diff line change
`@@ -149,7 +149,7 @@ public void RenderInsertOne<TDocument>(RenderArgs<BsonDocument> renderArgs, Bson`
`149`	`149`	`{`
`150`	`150`	`WriteStartModel(serializationContext, "insert", model);`
`151`	`151`	`var documentSerializer = _serializerRegistry.GetSerializer<TDocument>();`
`152`		`- var documentId = documentSerializer.SetDocumentIdIfMissing(null, model.Document);`
	`152`	`+ var documentId = documentSerializer.SetDocumentIdIfMissing(null, model.Document, serializationContext.SerializationDomain);`
`153`	`153`	`_idsMap[_currentIndex] = BsonValue.Create(documentId);`
`154`	`154`	`serializationContext.Writer.WriteName("document");`
`155`	`155`	`documentSerializer.Serialize(serializationContext, model.Document);`
Original file line number	Diff line number	Diff line change
`@@ -2205,7 +2205,7 @@ public override BsonDocument Render(RenderArgs<TDocument> args)`
`2205`	`2205`	`}`
`2206`	`2206`	`else`
`2207`	`2207`	`{`
`2208`		`- var discriminatorConvention = args.DocumentSerializer.GetDiscriminatorConvention();`
	`2208`	`+ var discriminatorConvention = args.DocumentSerializer.GetDiscriminatorConvention(args.SerializationDomain);`
`2209`	`2209`	`if (discriminatorConvention == null)`
`2210`	`2210`	`{`
`2211`	`2211`	`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)`
`2268`	`2268`	`}`
`2269`	`2269`	`else`
`2270`	`2270`	`{`
`2271`		`- var discriminatorConvention = renderedField.FieldSerializer.GetDiscriminatorConvention();`
	`2271`	`+ var discriminatorConvention = renderedField.FieldSerializer.GetDiscriminatorConvention(args.SerializationDomain);`
`2272`	`2272`	`if (discriminatorConvention == null)`
`2273`	`2273`	`{`
`2274`	`2274`	`var message = string.Format("OfType requires a discriminator convention for type: {0}.", BsonUtils.GetFriendlyTypeName(typeof(TField)));`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ public static TranslatedExpression Translate(TranslationContext context, MethodC`
`65`	`65`	`}`
`66`	`66`	`else`
`67`	`67`	`{`
`68`		`- var discriminatorConvention = nominalTypeSerializer.GetDiscriminatorConvention();`
	`68`	`+ var discriminatorConvention = nominalTypeSerializer.GetDiscriminatorConvention(context.SerializationDomain);`
`69`	`69`	`var itemVar = AstExpression.Var("item");`
`70`	`70`	`var discriminatorField = AstExpression.GetField(itemVar, discriminatorConvention.ElementName);`
`71`	`71`