Added getDiscriminatorInternal

papafe · papafe · commit c56f9725c4be · 2025-06-30T11:20:20.000+02:00
diff --git a/src/MongoDB.Bson/InternalExtensions.cs b/src/MongoDB.Bson/InternalExtensions.cs
@@ -20,7 +20,7 @@
 
 namespace MongoDB.Bson
 {
-    //TODO This could be moved somewhere else
+    //FP This could be moved somewhere else
     internal static class InternalExtensions
     {
         public static Type GetActualTypeInternal(this IDiscriminatorConvention discriminatorConvention, IBsonReader bsonReader, Type nominalType, IBsonSerializationDomain serializationDomain)
@@ -32,6 +32,15 @@ public static Type GetActualTypeInternal(this IDiscriminatorConvention discrimin
             return discriminatorConvention.GetActualType(bsonReader, nominalType);
         }
 
+        public static BsonValue GetDiscriminatorInternal(this IDiscriminatorConvention discriminatorConvention, Type nominalType, Type actualType, IBsonSerializationDomain serializationDomain)
+        {
+            if (discriminatorConvention is IDiscriminatorConventionInternal internalConvention)
+            {
+                return internalConvention.GetDiscriminator(nominalType, actualType, serializationDomain);
+            }
+            return discriminatorConvention.GetDiscriminator(nominalType, actualType);
+        }
+
         public static void ApplyInternal(this IMemberMapConvention memberMapConvention, BsonMemberMap memberMap, IBsonSerializationDomain serializationDomain)
         {
             if (memberMapConvention is IMemberMapConventionInternal internalConvention)
diff --git a/src/MongoDB.Bson/Serialization/Serializers/BsonClassMapSerializer.cs b/src/MongoDB.Bson/Serialization/Serializers/BsonClassMapSerializer.cs
@@ -329,7 +329,6 @@ public bool GetDocumentId(
             out IIdGenerator idGenerator)
             => GetDocumentId(document, BsonSerializer.DefaultSerializationDomain, out id, out idNominalType, out idGenerator);
 
-        /// <inheritdoc/>
         internal bool GetDocumentId(object document, IBsonSerializationDomain serializationDomain, out object id, out Type idNominalType,
             out IIdGenerator idGenerator)
         {
@@ -647,16 +646,7 @@ private void SerializeDiscriminator(BsonSerializationContext context, Type nomin
             if (discriminatorConvention != null)
             {
                 var actualType = obj.GetType();
-
-                BsonValue discriminator;
-                if (discriminatorConvention is IDiscriminatorConventionInternal discriminatorConventionInternal)
-                {
-                    discriminator = discriminatorConventionInternal.GetDiscriminator(nominalType, actualType, context.SerializationDomain);
-                }
-                else
-                {
-                    discriminator = discriminatorConvention.GetDiscriminator(nominalType, actualType);
-                }
+                var discriminator = discriminatorConvention.GetDiscriminatorInternal(nominalType, actualType, context.SerializationDomain);
 
                 if (discriminator != null)
                 {
diff --git a/src/MongoDB.Bson/Serialization/Serializers/BsonDocumentSerializer.cs b/src/MongoDB.Bson/Serialization/Serializers/BsonDocumentSerializer.cs
@@ -84,7 +84,6 @@ public bool GetDocumentId(
             out IIdGenerator idGenerator) => GetDocumentId(document, BsonSerializer.DefaultSerializationDomain, out id,
             out idNominalType, out idGenerator);
 
-        /// <inheritdoc />
         internal bool GetDocumentId(object document, IBsonSerializationDomain serializationDomain, out object id, out Type idNominalType,
             out IIdGenerator idGenerator)
         {
diff --git a/src/MongoDB.Bson/Serialization/Serializers/DiscriminatedWrapperSerializer.cs b/src/MongoDB.Bson/Serialization/Serializers/DiscriminatedWrapperSerializer.cs
@@ -145,7 +145,7 @@ public override void Serialize(BsonSerializationContext context, BsonSerializati
             var bsonWriter = context.Writer;
             var nominalType = args.NominalType;
             var actualType = value.GetType();
-            var discriminator = _discriminatorConvention.GetDiscriminator(nominalType, actualType);
+            var discriminator = _discriminatorConvention.GetDiscriminatorInternal(nominalType, actualType, context.SerializationDomain);
 
             bsonWriter.WriteStartDocument();
             if (discriminator != null)
diff --git a/src/MongoDB.Bson/Serialization/Serializers/ObjectSerializer.cs b/src/MongoDB.Bson/Serialization/Serializers/ObjectSerializer.cs
@@ -456,7 +456,7 @@ private void SerializeDiscriminatedValue(BsonSerializationContext context, BsonS
                 else
                 {
                     var bsonWriter = context.Writer;
-                    var discriminator = _discriminatorConvention.GetDiscriminator(typeof(object), actualType);
+                    var discriminator = _discriminatorConvention.GetDiscriminatorInternal(typeof(object), actualType, context.SerializationDomain);
 
                     bsonWriter.WriteStartDocument();
                     if (discriminator != null)
diff --git a/src/MongoDB.Driver.Authentication.AWS/SaslSteps/AWSLastSaslStep.cs b/src/MongoDB.Driver.Authentication.AWS/SaslSteps/AWSLastSaslStep.cs
@@ -82,7 +82,7 @@ private byte[] PreparePayload(AWSCredentials credentials, byte[] serverNonce, st
 
         private void ParseServerResponse(SaslConversation conversation, byte[] bytesReceivedFromServer, out byte[] serverNonce, out string host)
         {
-            var serverFirstMessageDocument = BsonSerializer.Deserialize<BsonDocument>(bytesReceivedFromServer);
+            var serverFirstMessageDocument = BsonSerializer.Deserialize<BsonDocument>(bytesReceivedFromServer);  //FP I think this is fine, as it should be default configuration.
             if (serverFirstMessageDocument.Names.Any(n => !__serverResponseExpectedNames.Contains(n)))
             {
                 var unexpectedNames = serverFirstMessageDocument.Names.Except(__serverResponseExpectedNames);
diff --git a/src/MongoDB.Driver.Encryption/ExplicitEncryptionLibMongoCryptController.cs b/src/MongoDB.Driver.Encryption/ExplicitEncryptionLibMongoCryptController.cs
@@ -102,7 +102,7 @@ public Guid CreateDataKey(
                 {
                     var wrappedKeyBytes = ProcessStates(context, _keyVaultNamespace.DatabaseNamespace.DatabaseName, cancellationToken);
 
-                    var wrappedKeyDocument = BsonSerializer.Deserialize<BsonDocument>(wrappedKeyBytes);
+                    var wrappedKeyDocument = BsonSerializer.Deserialize<BsonDocument>(wrappedKeyBytes); //FP I think this is fine, as it should be default configuration.
                     var keyId = UnwrapKeyId(wrappedKeyDocument);
 
                     _keyVaultCollection.Value.InsertOne(wrappedKeyDocument, cancellationToken: cancellationToken);
@@ -131,7 +131,7 @@ public async Task<Guid> CreateDataKeyAsync(
                 {
                     var wrappedKeyBytes = await ProcessStatesAsync(context, _keyVaultNamespace.DatabaseNamespace.DatabaseName, cancellationToken).ConfigureAwait(false);
 
-                    var wrappedKeyDocument = BsonSerializer.Deserialize<BsonDocument>(wrappedKeyBytes);
+                    var wrappedKeyDocument = BsonSerializer.Deserialize<BsonDocument>(wrappedKeyBytes); //FP I think this is fine, as it should be default configuration.
                     var keyId = UnwrapKeyId(wrappedKeyDocument);
 
                     await _keyVaultCollection.Value.InsertOneAsync(wrappedKeyDocument, cancellationToken: cancellationToken).ConfigureAwait(false);
@@ -553,7 +553,7 @@ private byte[] GetWrappedValueBytes(BsonValue value)
 
         private static BsonValue RenderFilter(FilterDefinition<BsonDocument> filter)
         {
-            var registry = BsonSerializer.SerializerRegistry;
+            var registry = BsonSerializer.SerializerRegistry; //FP I think this is fine, as it should be default configuration.
             var serializer = registry.GetSerializer<BsonDocument>();
             return filter.Render(new(serializer, registry));
         }
@@ -570,7 +570,7 @@ private static Guid UnwrapKeyId(BsonDocument wrappedKeyDocument)
 
         private static BsonValue UnwrapValue(byte[] encryptedWrappedBytes)
         {
-            var bsonDocument = BsonSerializer.Deserialize<BsonDocument>(encryptedWrappedBytes);
+            var bsonDocument = BsonSerializer.Deserialize<BsonDocument>(encryptedWrappedBytes); //FP I think this is fine, as it should be default configuration.
             return bsonDocument["v"];
         }
     }
diff --git a/src/MongoDB.Driver/Core/Operations/GroupOperation.cs b/src/MongoDB.Driver/Core/Operations/GroupOperation.cs
@@ -165,7 +165,7 @@ public async Task<IEnumerable<TResult>> ExecuteAsync(OperationContext operationC
         private ReadCommandOperation<TResult[]> CreateOperation()
         {
             var command = CreateCommand();
-            var resultSerializer = _resultSerializer ?? BsonSerializer.LookupSerializer<TResult>();
+            var resultSerializer = _resultSerializer ?? BsonSerializer.LookupSerializer<TResult>(); //FP Need to take a look
             var resultArraySerializer = new ArraySerializer<TResult>(resultSerializer);
             var commandResultSerializer = new ElementDeserializer<TResult[]>("retval", resultArraySerializer);
             return new ReadCommandOperation<TResult[]>(_collectionNamespace.DatabaseNamespace, command, commandResultSerializer, _messageEncoderSettings)
diff --git a/src/MongoDB.Driver/Core/WireProtocol/Messages/Encoders/JsonEncoders/MessageJsonEncoderBase.cs b/src/MongoDB.Driver/Core/WireProtocol/Messages/Encoders/JsonEncoders/MessageJsonEncoderBase.cs
@@ -67,7 +67,7 @@ public JsonWriter CreateJsonWriter()
                 writerSettings.OutputMode = _encoderSettings.GetOrDefault(MessageEncoderSettingsName.OutputMode, JsonOutputMode.Shell);
                 writerSettings.ShellVersion = _encoderSettings.GetOrDefault(MessageEncoderSettingsName.ShellVersion, new Version(2, 6, 0));
                 writerSettings.SerializationDomain =
-                    _encoderSettings.GetOrDefault<IBsonSerializationDomain>(MessageEncoderSettingsName.SerializationDomain, null); //TODO Using null here to find issues faster
+                    _encoderSettings.GetOrDefault<IBsonSerializationDomain>(MessageEncoderSettingsName.SerializationDomain, null); //FP Using null here to find issues faster
             }
             return new JsonWriter(_textWriter, writerSettings);
         }
diff --git a/src/MongoDB.Driver/FilterDefinitionBuilder.cs b/src/MongoDB.Driver/FilterDefinitionBuilder.cs
@@ -2212,7 +2212,7 @@ public override BsonDocument Render(RenderArgs<TDocument> args)
                     throw new NotSupportedException(message);
                 }
 
-                var discriminator = discriminatorConvention.GetDiscriminator(typeof(TDocument), typeof(TDerived));
+                var discriminator = discriminatorConvention.GetDiscriminatorInternal(typeof(TDocument), typeof(TDerived), args.SerializationDomain);
                 if (discriminator == null)
                 {
                     throw new NotSupportedException($"OfType requires that documents of type {BsonUtils.GetFriendlyTypeName(typeof(TDerived))} have a discriminator value.");
@@ -2221,8 +2221,8 @@ public override BsonDocument Render(RenderArgs<TDocument> args)
                 var discriminatorField = new AstFilterField(discriminatorConvention.ElementName);
                 ofTypeFilter= discriminatorConvention switch
                 {
-                    IHierarchicalDiscriminatorConvention hierarchicalDiscriminatorConvention => DiscriminatorAstFilter.TypeIs(discriminatorField, hierarchicalDiscriminatorConvention, nominalType, actualType),
-                    IScalarDiscriminatorConvention scalarDiscriminatorConvention => DiscriminatorAstFilter.TypeIs(discriminatorField, scalarDiscriminatorConvention, nominalType, actualType),
+                    IHierarchicalDiscriminatorConvention hierarchicalDiscriminatorConvention => DiscriminatorAstFilter.TypeIs(discriminatorField, hierarchicalDiscriminatorConvention, nominalType, actualType, args.SerializationDomain),
+                    IScalarDiscriminatorConvention scalarDiscriminatorConvention => DiscriminatorAstFilter.TypeIs(discriminatorField, scalarDiscriminatorConvention, nominalType, actualType, args.SerializationDomain),
                     _ => throw new NotSupportedException("OfType is not supported with the configured discriminator convention.")
                 };
             }
@@ -2280,8 +2280,8 @@ public override BsonDocument Render(RenderArgs<TDocument> args)
 
                 ofTypeFilter = discriminatorConvention switch
                 {
-                    IHierarchicalDiscriminatorConvention hierarchicalDiscriminatorConvention => DiscriminatorAstFilter.TypeIs(discriminatorField, hierarchicalDiscriminatorConvention, nominalType, actualType),
-                    IScalarDiscriminatorConvention scalarDiscriminatorConvention => DiscriminatorAstFilter.TypeIs(discriminatorField, scalarDiscriminatorConvention, nominalType, actualType),
+                    IHierarchicalDiscriminatorConvention hierarchicalDiscriminatorConvention => DiscriminatorAstFilter.TypeIs(discriminatorField, hierarchicalDiscriminatorConvention, nominalType, actualType, args.SerializationDomain),
+                    IScalarDiscriminatorConvention scalarDiscriminatorConvention => DiscriminatorAstFilter.TypeIs(discriminatorField, scalarDiscriminatorConvention, nominalType, actualType, args.SerializationDomain),
                     _ => throw new NotSupportedException("OfType is not supported with the configured discriminator convention.")
                 };
             }
diff --git a/src/MongoDB.Driver/GridFS/GridFSBucketOptions.cs b/src/MongoDB.Driver/GridFS/GridFSBucketOptions.cs
@@ -243,7 +243,8 @@ public ReadPreference ReadPreference
         /// </value>
         public IBsonSerializerRegistry SerializerRegistry
         {
-            get { return BsonSerializer.SerializerRegistry; }  //QUESTION What do we do in this case...? Given it's read only, we could ignore it? Also, why the immutable options have a serializer registry and the non-immutable options do not?
+            get { return BsonSerializer.SerializerRegistry; }  //QUESTION What do we do in this case...? Given it's read only, we could ignore it? Given this is used for default serialization, it should be ok.
+                                                               //Also, why the immutable options have a serializer registry and the non-immutable options do not?
         }
 
         /// <summary>
diff --git a/src/MongoDB.Driver/GridFS/GridFSFileInfoSerializer.cs b/src/MongoDB.Driver/GridFS/GridFSFileInfoSerializer.cs
@@ -31,7 +31,7 @@ public class GridFSFileInfoSerializer<TFileId> : BsonDocumentBackedClassSerializ
         /// Initializes a new instance of the <see cref="GridFSFileInfoSerializer" /> class.
         /// </summary>
         public GridFSFileInfoSerializer()
-            : this(BsonSerializer.LookupSerializer<TFileId>())
+            : this(BsonSerializer.LookupSerializer<TFileId>())  //FP I think this should be fine.
         {
         }
 
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/DiscriminatorAstFilter.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/DiscriminatorAstFilter.cs
@@ -16,6 +16,7 @@
 using System;
 using System.Linq;
 using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
 using MongoDB.Bson.Serialization.Conventions;
 using MongoDB.Bson.Serialization.Serializers;
 using MongoDB.Driver.Linq.Linq3Implementation.Ast.Filters;
@@ -24,9 +25,9 @@ namespace MongoDB.Driver.Linq.Linq3Implementation.Translators;
 
 internal static class DiscriminatorAstFilter
 {
-    public static AstFilter TypeEquals(AstFilterField discriminatorField, IHierarchicalDiscriminatorConvention discriminatorConvention, Type nominalType, Type actualType)
+    public static AstFilter TypeEquals(AstFilterField discriminatorField, IHierarchicalDiscriminatorConvention discriminatorConvention, Type nominalType, Type actualType, IBsonSerializationDomain serializationDomain)
     {
-        var discriminator = discriminatorConvention.GetDiscriminator(nominalType, actualType);
+        var discriminator = discriminatorConvention.GetDiscriminatorInternal(nominalType, actualType, serializationDomain);
         if (discriminator == null)
         {
             return AstFilter.NotExists(discriminatorField);
@@ -44,22 +45,22 @@ public static AstFilter TypeEquals(AstFilterField discriminatorField, IHierarchi
         }
     }
 
-    public static AstFilter TypeEquals(AstFilterField discriminatorField, IDiscriminatorConvention discriminatorConvention, Type nominalType, Type actualType)
+    public static AstFilter TypeEquals(AstFilterField discriminatorField, IDiscriminatorConvention discriminatorConvention, Type nominalType, Type actualType, IBsonSerializationDomain serializationDomain)
     {
-        var discriminator = discriminatorConvention.GetDiscriminator(nominalType, actualType);
+        var discriminator = discriminatorConvention.GetDiscriminatorInternal(nominalType, actualType, serializationDomain);
         return discriminator == null ?
             AstFilter.NotExists(discriminatorField) :
             AstFilter.Eq(discriminatorField, discriminator);
     }
 
-    public static AstFieldOperationFilter TypeIs(AstFilterField discriminatorField, IHierarchicalDiscriminatorConvention discriminatorConvention, Type nominalType, Type actualType)
+    public static AstFieldOperationFilter TypeIs(AstFilterField discriminatorField, IHierarchicalDiscriminatorConvention discriminatorConvention, Type nominalType, Type actualType, IBsonSerializationDomain serializationDomain)
     {
-        var discriminator = discriminatorConvention.GetDiscriminator(nominalType, actualType);
+        var discriminator = discriminatorConvention.GetDiscriminatorInternal(nominalType, actualType, serializationDomain);
         var lastItem = discriminator is BsonArray array ? array.Last() : discriminator;
         return AstFilter.Eq(discriminatorField, lastItem); // will match subclasses also
     }
 
-    public static AstFieldOperationFilter TypeIs(AstFilterField discriminatorField, IScalarDiscriminatorConvention discriminatorConvention, Type nominalType, Type actualType)
+    public static AstFieldOperationFilter TypeIs(AstFilterField discriminatorField, IScalarDiscriminatorConvention discriminatorConvention, Type nominalType, Type actualType, IBsonSerializationDomain serializationDomain)
     {
         var discriminators = discriminatorConvention.GetDiscriminatorsForTypeAndSubTypes(actualType);
         return discriminators.Length == 1 ?
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/ExpressionTranslators/GetTypeComparisonExpressionToFilterTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/ExpressionTranslators/GetTypeComparisonExpressionToFilterTranslator.cs
@@ -60,8 +60,8 @@ public static AstFilter Translate(
 
                 var filter = discriminatorConvention switch
                 {
-                    IHierarchicalDiscriminatorConvention hierarchicalDiscriminatorConvention => DiscriminatorAstFilter.TypeEquals(discriminatorField, hierarchicalDiscriminatorConvention, nominalType, actualType),
-                    _ => DiscriminatorAstFilter.TypeEquals(discriminatorField, discriminatorConvention, nominalType, actualType),
+                    IHierarchicalDiscriminatorConvention hierarchicalDiscriminatorConvention => DiscriminatorAstFilter.TypeEquals(discriminatorField, hierarchicalDiscriminatorConvention, nominalType, actualType, context.SerializationDomain),
+                    _ => DiscriminatorAstFilter.TypeEquals(discriminatorField, discriminatorConvention, nominalType, actualType, context.SerializationDomain),
                 };
 
                 return comparisonOperator 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
@@ -46,8 +46,8 @@ public static AstFilter Translate(TranslationContext context, TypeBinaryExpressi
 
                     return discriminatorConvention switch
                     {
-                        IHierarchicalDiscriminatorConvention hierarchicalDiscriminatorConvention => DiscriminatorAstFilter.TypeIs(discriminatorField, hierarchicalDiscriminatorConvention, nominalType, actualType),
-                        IScalarDiscriminatorConvention scalarDiscriminatorConvention => DiscriminatorAstFilter.TypeIs(discriminatorField, scalarDiscriminatorConvention, nominalType, actualType),
+                        IHierarchicalDiscriminatorConvention hierarchicalDiscriminatorConvention => DiscriminatorAstFilter.TypeIs(discriminatorField, hierarchicalDiscriminatorConvention, nominalType, actualType, context.SerializationDomain),
+                        IScalarDiscriminatorConvention scalarDiscriminatorConvention => DiscriminatorAstFilter.TypeIs(discriminatorField, scalarDiscriminatorConvention, nominalType, actualType, context.SerializationDomain),
                         _ => throw new ExpressionNotSupportedException(expression, because: "is operator is not supported with the configured discriminator convention")
                     };
                 }
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/MethodTranslators/AllOrAnyMethodToFilterTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/MethodTranslators/AllOrAnyMethodToFilterTranslator.cs
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToPipelineTranslators/OfTypeMethodToPipelineTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToPipelineTranslators/OfTypeMethodToPipelineTranslator.cs
diff --git a/src/MongoDB.Driver/OfTypeMongoCollection.cs b/src/MongoDB.Driver/OfTypeMongoCollection.cs
diff --git a/src/MongoDB.Driver/PipelineStageDefinitionBuilder.cs b/src/MongoDB.Driver/PipelineStageDefinitionBuilder.cs

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@`
`20`	`20`
`21`	`21`	`namespace MongoDB.Bson`
`22`	`22`	`{`
`23`		`- //TODO This could be moved somewhere else`
	`23`	`+ //FP This could be moved somewhere else`
`24`	`24`	`internal static class InternalExtensions`
`25`	`25`	`{`
`26`	`26`	`public static Type GetActualTypeInternal(this IDiscriminatorConvention discriminatorConvention, IBsonReader bsonReader, Type nominalType, IBsonSerializationDomain serializationDomain)`
`@@ -32,6 +32,15 @@ public static Type GetActualTypeInternal(this IDiscriminatorConvention discrimin`
`32`	`32`	`return discriminatorConvention.GetActualType(bsonReader, nominalType);`
`33`	`33`	`}`
`34`	`34`
	`35`	`+ public static BsonValue GetDiscriminatorInternal(this IDiscriminatorConvention discriminatorConvention, Type nominalType, Type actualType, IBsonSerializationDomain serializationDomain)`
	`36`	`+ {`
	`37`	`+ if (discriminatorConvention is IDiscriminatorConventionInternal internalConvention)`
	`38`	`+ {`
	`39`	`+ return internalConvention.GetDiscriminator(nominalType, actualType, serializationDomain);`
	`40`	`+ }`
	`41`	`+ return discriminatorConvention.GetDiscriminator(nominalType, actualType);`
	`42`	`+ }`
	`43`	`+`
`35`	`44`	`public static void ApplyInternal(this IMemberMapConvention memberMapConvention, BsonMemberMap memberMap, IBsonSerializationDomain serializationDomain)`
`36`	`45`	`{`
`37`	`46`	`if (memberMapConvention is IMemberMapConventionInternal internalConvention)`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,6 @@ public bool GetDocumentId(`
`84`	`84`	`out IIdGenerator idGenerator) => GetDocumentId(document, BsonSerializer.DefaultSerializationDomain, out id,`
`85`	`85`	`out idNominalType, out idGenerator);`
`86`	`86`
`87`		`- /// <inheritdoc />`
`88`	`87`	`internal bool GetDocumentId(object document, IBsonSerializationDomain serializationDomain, out object id, out Type idNominalType,`
`89`	`88`	`out IIdGenerator idGenerator)`
`90`	`89`	`{`
Original file line number	Diff line number	Diff line change
`@@ -456,7 +456,7 @@ private void SerializeDiscriminatedValue(BsonSerializationContext context, BsonS`
`456`	`456`	`else`
`457`	`457`	`{`
`458`	`458`	`var bsonWriter = context.Writer;`
`459`		`- var discriminator = _discriminatorConvention.GetDiscriminator(typeof(object), actualType);`
	`459`	`+ var discriminator = _discriminatorConvention.GetDiscriminatorInternal(typeof(object), actualType, context.SerializationDomain);`
`460`	`460`
`461`	`461`	`bsonWriter.WriteStartDocument();`
`462`	`462`	`if (discriminator != null)`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ private byte[] PreparePayload(AWSCredentials credentials, byte[] serverNonce, st`
`82`	`82`
`83`	`83`	`private void ParseServerResponse(SaslConversation conversation, byte[] bytesReceivedFromServer, out byte[] serverNonce, out string host)`
`84`	`84`	`{`
`85`		`- var serverFirstMessageDocument = BsonSerializer.Deserialize<BsonDocument>(bytesReceivedFromServer);`
	`85`	`+ var serverFirstMessageDocument = BsonSerializer.Deserialize<BsonDocument>(bytesReceivedFromServer); //FP I think this is fine, as it should be default configuration.`
`86`	`86`	`if (serverFirstMessageDocument.Names.Any(n => !__serverResponseExpectedNames.Contains(n)))`
`87`	`87`	`{`
`88`	`88`	`var unexpectedNames = serverFirstMessageDocument.Names.Except(__serverResponseExpectedNames);`
Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,7 @@ public Guid CreateDataKey(`
`102`	`102`	`{`
`103`	`103`	`var wrappedKeyBytes = ProcessStates(context, _keyVaultNamespace.DatabaseNamespace.DatabaseName, cancellationToken);`
`104`	`104`
`105`		`- var wrappedKeyDocument = BsonSerializer.Deserialize<BsonDocument>(wrappedKeyBytes);`
	`105`	`+ var wrappedKeyDocument = BsonSerializer.Deserialize<BsonDocument>(wrappedKeyBytes); //FP I think this is fine, as it should be default configuration.`
`106`	`106`	`var keyId = UnwrapKeyId(wrappedKeyDocument);`
`107`	`107`
`108`	`108`	`_keyVaultCollection.Value.InsertOne(wrappedKeyDocument, cancellationToken: cancellationToken);`
`@@ -131,7 +131,7 @@ public async Task<Guid> CreateDataKeyAsync(`
`131`	`131`	`{`
`132`	`132`	`var wrappedKeyBytes = await ProcessStatesAsync(context, _keyVaultNamespace.DatabaseNamespace.DatabaseName, cancellationToken).ConfigureAwait(false);`
`133`	`133`
`134`		`- var wrappedKeyDocument = BsonSerializer.Deserialize<BsonDocument>(wrappedKeyBytes);`
	`134`	`+ var wrappedKeyDocument = BsonSerializer.Deserialize<BsonDocument>(wrappedKeyBytes); //FP I think this is fine, as it should be default configuration.`
`135`	`135`	`var keyId = UnwrapKeyId(wrappedKeyDocument);`
`136`	`136`
`137`	`137`	`await _keyVaultCollection.Value.InsertOneAsync(wrappedKeyDocument, cancellationToken: cancellationToken).ConfigureAwait(false);`
`@@ -553,7 +553,7 @@ private byte[] GetWrappedValueBytes(BsonValue value)`
`553`	`553`
`554`	`554`	`private static BsonValue RenderFilter(FilterDefinition<BsonDocument> filter)`
`555`	`555`	`{`
`556`		`- var registry = BsonSerializer.SerializerRegistry;`
	`556`	`+ var registry = BsonSerializer.SerializerRegistry; //FP I think this is fine, as it should be default configuration.`
`557`	`557`	`var serializer = registry.GetSerializer<BsonDocument>();`
`558`	`558`	`return filter.Render(new(serializer, registry));`
`559`	`559`	`}`
`@@ -570,7 +570,7 @@ private static Guid UnwrapKeyId(BsonDocument wrappedKeyDocument)`
`570`	`570`
`571`	`571`	`private static BsonValue UnwrapValue(byte[] encryptedWrappedBytes)`
`572`	`572`	`{`
`573`		`- var bsonDocument = BsonSerializer.Deserialize<BsonDocument>(encryptedWrappedBytes);`
	`573`	`+ var bsonDocument = BsonSerializer.Deserialize<BsonDocument>(encryptedWrappedBytes); //FP I think this is fine, as it should be default configuration.`
`574`	`574`	`return bsonDocument["v"];`
`575`	`575`	`}`
`576`	`576`	`}`
Original file line number	Diff line number	Diff line change
`@@ -165,7 +165,7 @@ public async Task<IEnumerable<TResult>> ExecuteAsync(OperationContext operationC`
`165`	`165`	`private ReadCommandOperation<TResult[]> CreateOperation()`
`166`	`166`	`{`
`167`	`167`	`var command = CreateCommand();`
`168`		`- var resultSerializer = _resultSerializer ?? BsonSerializer.LookupSerializer<TResult>();`
	`168`	`+ var resultSerializer = _resultSerializer ?? BsonSerializer.LookupSerializer<TResult>(); //FP Need to take a look`
`169`	`169`	`var resultArraySerializer = new ArraySerializer<TResult>(resultSerializer);`
`170`	`170`	`var commandResultSerializer = new ElementDeserializer<TResult[]>("retval", resultArraySerializer);`
`171`	`171`	`return new ReadCommandOperation<TResult[]>(_collectionNamespace.DatabaseNamespace, command, commandResultSerializer, _messageEncoderSettings)`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ public JsonWriter CreateJsonWriter()`
`67`	`67`	`writerSettings.OutputMode = _encoderSettings.GetOrDefault(MessageEncoderSettingsName.OutputMode, JsonOutputMode.Shell);`
`68`	`68`	`writerSettings.ShellVersion = _encoderSettings.GetOrDefault(MessageEncoderSettingsName.ShellVersion, new Version(2, 6, 0));`
`69`	`69`	`writerSettings.SerializationDomain =`
`70`		`- _encoderSettings.GetOrDefault<IBsonSerializationDomain>(MessageEncoderSettingsName.SerializationDomain, null); //TODO Using null here to find issues faster`
	`70`	`+ _encoderSettings.GetOrDefault<IBsonSerializationDomain>(MessageEncoderSettingsName.SerializationDomain, null); //FP Using null here to find issues faster`
`71`	`71`	`}`
`72`	`72`	`return new JsonWriter(_textWriter, writerSettings);`
`73`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2212,7 +2212,7 @@ public override BsonDocument Render(RenderArgs<TDocument> args)`
`2212`	`2212`	`throw new NotSupportedException(message);`
`2213`	`2213`	`}`
`2214`	`2214`
`2215`		`- var discriminator = discriminatorConvention.GetDiscriminator(typeof(TDocument), typeof(TDerived));`
	`2215`	`+ var discriminator = discriminatorConvention.GetDiscriminatorInternal(typeof(TDocument), typeof(TDerived), args.SerializationDomain);`
`2216`	`2216`	`if (discriminator == null)`
`2217`	`2217`	`{`
`2218`	`2218`	`throw new NotSupportedException($"OfType requires that documents of type {BsonUtils.GetFriendlyTypeName(typeof(TDerived))} have a discriminator value.");`
`@@ -2221,8 +2221,8 @@ public override BsonDocument Render(RenderArgs<TDocument> args)`
`2221`	`2221`	`var discriminatorField = new AstFilterField(discriminatorConvention.ElementName);`
`2222`	`2222`	`ofTypeFilter= discriminatorConvention switch`
`2223`	`2223`	`{`
`2224`		`- IHierarchicalDiscriminatorConvention hierarchicalDiscriminatorConvention => DiscriminatorAstFilter.TypeIs(discriminatorField, hierarchicalDiscriminatorConvention, nominalType, actualType),`
`2225`		`- IScalarDiscriminatorConvention scalarDiscriminatorConvention => DiscriminatorAstFilter.TypeIs(discriminatorField, scalarDiscriminatorConvention, nominalType, actualType),`
	`2224`	`+ IHierarchicalDiscriminatorConvention hierarchicalDiscriminatorConvention => DiscriminatorAstFilter.TypeIs(discriminatorField, hierarchicalDiscriminatorConvention, nominalType, actualType, args.SerializationDomain),`
	`2225`	`+ IScalarDiscriminatorConvention scalarDiscriminatorConvention => DiscriminatorAstFilter.TypeIs(discriminatorField, scalarDiscriminatorConvention, nominalType, actualType, args.SerializationDomain),`
`2226`	`2226`	`_ => throw new NotSupportedException("OfType is not supported with the configured discriminator convention.")`
`2227`	`2227`	`};`
`2228`	`2228`	`}`
`@@ -2280,8 +2280,8 @@ public override BsonDocument Render(RenderArgs<TDocument> args)`
`2280`	`2280`
`2281`	`2281`	`ofTypeFilter = discriminatorConvention switch`
`2282`	`2282`	`{`
`2283`		`- IHierarchicalDiscriminatorConvention hierarchicalDiscriminatorConvention => DiscriminatorAstFilter.TypeIs(discriminatorField, hierarchicalDiscriminatorConvention, nominalType, actualType),`
`2284`		`- IScalarDiscriminatorConvention scalarDiscriminatorConvention => DiscriminatorAstFilter.TypeIs(discriminatorField, scalarDiscriminatorConvention, nominalType, actualType),`
	`2283`	`+ IHierarchicalDiscriminatorConvention hierarchicalDiscriminatorConvention => DiscriminatorAstFilter.TypeIs(discriminatorField, hierarchicalDiscriminatorConvention, nominalType, actualType, args.SerializationDomain),`
	`2284`	`+ IScalarDiscriminatorConvention scalarDiscriminatorConvention => DiscriminatorAstFilter.TypeIs(discriminatorField, scalarDiscriminatorConvention, nominalType, actualType, args.SerializationDomain),`
`2285`	`2285`	`_ => throw new NotSupportedException("OfType is not supported with the configured discriminator convention.")`
`2286`	`2286`	`};`
`2287`	`2287`	`}`