CSHARP-5846: Global GuidSerializer settings ignored for object-typed properties (#1990)

Author: papafe

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

@@ -60,7 +60,7 @@ public sealed class ObjectSerializer : ClassSerializerBase<object>, IHasDiscrimi
         private readonly Func<Type, bool> _allowedSerializationTypes;
         private readonly IDiscriminatorConvention _discriminatorConvention;
         private readonly GuidRepresentation _guidRepresentation;
-        private readonly GuidSerializer _guidSerializer;
+        private readonly Lazy<IBsonSerializer<Guid>> _guidSerializer;
 
         // constructors
         /// <summary>
@@ -135,10 +135,17 @@ public ObjectSerializer(
             Func<Type, bool> allowedSerializationTypes)
         {
             _discriminatorConvention = discriminatorConvention ?? throw new ArgumentNullException(nameof(discriminatorConvention));
-            _guidRepresentation = guidRepresentation;
-            _guidSerializer = new GuidSerializer(_guidRepresentation);
             _allowedDeserializationTypes = allowedDeserializationTypes ?? throw new ArgumentNullException(nameof(allowedDeserializationTypes));
             _allowedSerializationTypes = allowedSerializationTypes ?? throw new ArgumentNullException(nameof(allowedSerializationTypes));
+            _guidRepresentation = guidRepresentation;
+            if (guidRepresentation != GuidRepresentation.Unspecified)
+            {
+                _guidSerializer = new Lazy<IBsonSerializer<Guid>>(() => new GuidSerializer(guidRepresentation));
+            }
+            else
+            {
+                _guidSerializer = new Lazy<IBsonSerializer<Guid>>(() => BsonSerializer.LookupSerializer<Guid>());
+            }
         }
 
         // public properties
@@ -190,7 +197,7 @@ public override object Deserialize(BsonDeserializationContext context, BsonDeser
                     if (subType == BsonBinarySubType.UuidStandard || subType == BsonBinarySubType.UuidLegacy)
                     {
                         bsonReader.ReturnToBookmark(binaryDataBookmark);
-                        return _guidSerializer.Deserialize(context);
+                        return _guidSerializer.Value.Deserialize(context);
                     }
                     goto default;
 
@@ -317,7 +324,7 @@ public override void Serialize(BsonSerializationContext context, BsonSerializati
                                 if (actualType == typeof(Guid))
                                 {
                                     var guid = (Guid)value;
-                                    _guidSerializer.Serialize(context, args, guid);
+                                    _guidSerializer.Value.Serialize(context, args, guid);
                                     return;
                                 }
                                 if (actualType == typeof(ObjectId))

tests/MongoDB.Bson.Tests/Serialization/Serializers/ObjectSerializerTests.cs

@@ -14,9 +14,11 @@
 */
 
 using System;
+using System.Collections.Concurrent;
 using System.Dynamic;
 using System.IO;
 using System.Linq;
+using System.Reflection;
 using FluentAssertions;
 using MongoDB.Bson.IO;
 using MongoDB.Bson.Serialization;
@@ -725,6 +727,127 @@ public void Serialize_guid_should_throw_when_guid_representation_is_unspecified(
                 exception.Should().BeOfType<BsonSerializationException>();
             }
         }
+
+        [Fact]
+        public void Deserialize_binary_data_should_use_globally_registered_guid_serializer_when_guid_representation_is_unspecified()
+        {
+            var discriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(typeof(object));
+            var guid = Guid.NewGuid();
+            var bson = new BsonDocument("x", new BsonBinaryData(guid, GuidRepresentation.CSharpLegacy)).ToBson();
+            object result = null;
+
+            WithRegisteredGuidSerializer(GuidRepresentation.CSharpLegacy, () =>
+            {
+                var subject = new ObjectSerializer(discriminatorConvention, GuidRepresentation.Unspecified);
+
+                using var memoryStream = new MemoryStream(bson);
+                using var reader = new BsonBinaryReader(memoryStream);
+                var context = BsonDeserializationContext.CreateRoot(reader);
+                reader.ReadStartDocument();
+                reader.ReadName("x");
+                result = subject.Deserialize<object>(context);
+            });
+
+            result.Should().Be(guid);
+        }
+
+        [Fact]
+        public void Deserialize_binary_data_should_use_guid_serializer_registered_after_object_serializer_is_constructed()
+        {
+            var discriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(typeof(object));
+            var subject = new ObjectSerializer(discriminatorConvention, GuidRepresentation.Unspecified);
+            var guid = Guid.NewGuid();
+            var bson = new BsonDocument("x", new BsonBinaryData(guid, GuidRepresentation.CSharpLegacy)).ToBson();
+            object result = null;
+
+            WithRegisteredGuidSerializer(GuidRepresentation.CSharpLegacy, () =>
+            {
+                using var memoryStream = new MemoryStream(bson);
+                using var reader = new BsonBinaryReader(memoryStream);
+                var context = BsonDeserializationContext.CreateRoot(reader);
+                reader.ReadStartDocument();
+                reader.ReadName("x");
+                result = subject.Deserialize<object>(context);
+            });
+
+            result.Should().Be(guid);
+        }
+
+        [Fact]
+        public void Serialize_guid_should_use_globally_registered_guid_serializer_when_guid_representation_is_unspecified()
+        {
+            var discriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(typeof(object));
+            var guid = Guid.NewGuid();
+            BsonBinaryData binaryData = null;
+
+            WithRegisteredGuidSerializer(GuidRepresentation.CSharpLegacy, () =>
+            {
+                var subject = new ObjectSerializer(discriminatorConvention, GuidRepresentation.Unspecified);
+
+                using var memoryStream = new MemoryStream();
+                using var writer = new BsonBinaryWriter(memoryStream);
+                var context = BsonSerializationContext.CreateRoot(writer);
+                writer.WriteStartDocument();
+                writer.WriteName("x");
+                subject.Serialize(context, guid);
+                writer.WriteEndDocument();
+
+                binaryData = BsonSerializer.Deserialize<BsonDocument>(memoryStream.ToArray())["x"].AsBsonBinaryData;
+            });
+
+            binaryData.SubType.Should().Be(BsonBinarySubType.UuidLegacy);
+            binaryData.ToGuid(GuidRepresentation.CSharpLegacy).Should().Be(guid);
+        }
+
+        [Fact]
+        public void Serialize_guid_should_use_guid_serializer_registered_after_object_serializer_is_constructed()
+        {
+            var discriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(typeof(object));
+            var subject = new ObjectSerializer(discriminatorConvention, GuidRepresentation.Unspecified);
+            var guid = Guid.NewGuid();
+            BsonBinaryData binaryData = null;
+
+            WithRegisteredGuidSerializer(GuidRepresentation.CSharpLegacy, () =>
+            {
+                using var memoryStream = new MemoryStream();
+                using var writer = new BsonBinaryWriter(memoryStream);
+                var context = BsonSerializationContext.CreateRoot(writer);
+                writer.WriteStartDocument();
+                writer.WriteName("x");
+                subject.Serialize(context, guid);
+                writer.WriteEndDocument();
+
+                binaryData = BsonSerializer.Deserialize<BsonDocument>(memoryStream.ToArray())["x"].AsBsonBinaryData;
+            });
+
+            binaryData.SubType.Should().Be(BsonBinarySubType.UuidLegacy);
+            binaryData.ToGuid(GuidRepresentation.CSharpLegacy).Should().Be(guid);
+        }
+
+        private static void WithRegisteredGuidSerializer(GuidRepresentation registeredGuidRepresentation, Action action)
+        {
+            var cacheField = typeof(BsonSerializerRegistry).GetField("_cache", BindingFlags.NonPublic | BindingFlags.Instance);
+            var cache = (ConcurrentDictionary<Type, IBsonSerializer>)cacheField.GetValue(BsonSerializer.SerializerRegistry);
+
+            cache.TryGetValue(typeof(Guid), out var savedSerializer);
+            var newSerializer = new GuidSerializer(registeredGuidRepresentation);
+            cache.AddOrUpdate(typeof(Guid), newSerializer, (_, __) => newSerializer);
+            try
+            {
+                action();
+            }
+            finally
+            {
+                if (savedSerializer != null)
+                {
+                    cache.AddOrUpdate(typeof(Guid), savedSerializer, (_, __) => savedSerializer);
+                }
+                else
+                {
+                    cache.TryRemove(typeof(Guid), out _);
+                }
+            }
+        }
     }
 
     public class DefaultAllowedTypesTests