CSHARP-4659: Improve BsonClassMapSerializer to support stuctures (#1098)

sanych-sun · web-flow · commit 531fa6ecac29 · 2023-05-30T13:55:09.000-07:00
diff --git a/src/MongoDB.Bson/Serialization/BsonMemberMap.cs b/src/MongoDB.Bson/Serialization/BsonMemberMap.cs
@@ -577,6 +577,12 @@ private Action<object, object> GetFieldSetter()
                 throw new BsonSerializationException(message);
             }
 
+            if (fieldInfo.DeclaringType.IsValueType)
+            {
+                // Fallback to reflection for value type to avoid boxing-unboxing problems
+                return (instance, value) => fieldInfo.SetValue(instance, value);
+            }
+
             var objParameter = Expression.Parameter(typeof(object), "obj");
             var valueParameter = Expression.Parameter(typeof(object), "value");
             var field = Expression.Field(Expression.Convert(objParameter, fieldInfo.DeclaringType), fieldInfo);
@@ -630,6 +636,12 @@ private Action<object, object> GetPropertySetter()
                 throw new BsonSerializationException(message);
             }
 
+            if (propertyInfo.DeclaringType.IsValueType)
+            {
+                // Fallback to reflection for value type to avoid boxing-unboxing problems
+                return (instance, value) => propertyInfo.SetValue(instance, value);
+            }
+
             // lambdaExpression = (obj, value) => ((TClass) obj).SetMethod((TMember) value)
             var objParameter = Expression.Parameter(typeof(object), "obj");
             var valueParameter = Expression.Parameter(typeof(object), "value");
diff --git a/src/MongoDB.Bson/Serialization/Serializers/BsonClassMapSerializer.cs b/src/MongoDB.Bson/Serialization/Serializers/BsonClassMapSerializer.cs
@@ -30,8 +30,6 @@ public class BsonClassMapSerializer<TClass> : SerializerBase<TClass>, IBsonIdPro
     {
         // private fields
         private readonly BsonClassMap _classMap;
-        private readonly bool _isReferenceType;
-        private readonly bool _isValueType;
 
         // constructors
         /// <summary>
@@ -42,21 +40,19 @@ public BsonClassMapSerializer(BsonClassMap classMap)
         {
             if (classMap == null)
             {
-                throw new ArgumentNullException("classMap");
+                throw new ArgumentNullException(nameof(classMap));
             }
             if (classMap.ClassType != typeof(TClass))
             {
                 var message = string.Format("Must be a BsonClassMap for the type {0}.", typeof(TClass));
-                throw new ArgumentException(message, "classMap");
+                throw new ArgumentException(message, nameof(classMap));
             }
             if (!classMap.IsFrozen)
             {
                 throw new ArgumentException("Class map is not frozen.", nameof(classMap));
             }
 
             _classMap = classMap;
-            _isValueType = _classMap.ClassType.IsValueType;
-            _isReferenceType = !_isValueType;
         }
 
         // public properties
@@ -87,22 +83,17 @@ public override TClass Deserialize(BsonDeserializationContext context, BsonDeser
                 bsonReader.ReadNull();
                 return default(TClass);
             }
-            else
-            {
-                var discriminatorConvention = _classMap.GetDiscriminatorConvention();
 
-                var actualType = discriminatorConvention.GetActualType(bsonReader, args.NominalType);
-                if (actualType == typeof(TClass))
-                {
-                    return DeserializeClass(context);
-                }
-                else
-                {
-                    var serializer = BsonSerializer.LookupSerializer(actualType);
-                    return (TClass)serializer.Deserialize(context);
-                }
+            var discriminatorConvention = _classMap.GetDiscriminatorConvention();
 
+            var actualType = discriminatorConvention.GetActualType(bsonReader, args.NominalType);
+            if (actualType == typeof(TClass))
+            {
+                return DeserializeClass(context);
             }
+
+            var serializer = BsonSerializer.LookupSerializer(actualType);
+            return (TClass)serializer.Deserialize(context);
         }
 
         /// <summary>
@@ -124,7 +115,9 @@ public TClass DeserializeClass(BsonDeserializationContext context)
             }
 
             Dictionary<string, object> values = null;
-            var document = default(TClass);
+            // Important for struct support:
+            // should use object variable here, so created value should be boxed right away!
+            object document = null;
 
             ISupportInitialize supportsInitialization = null;
             if (_classMap.HasCreatorMaps)
@@ -135,13 +128,7 @@ public TClass DeserializeClass(BsonDeserializationContext context)
             else
             {
                 // for mutable classes we deserialize the values directly into the result object
-                if (_isValueType)
-                {
-                    var message = string.Format("Value class {0} cannot be deserialized without a constructor.", _classMap.ClassType.FullName);
-                    throw new BsonSerializationException(message);
-                }
-
-                document = (TClass)_classMap.CreateInstance();
+                document = _classMap.CreateInstance();
 
                 if (document == null)
                 {
@@ -173,7 +160,7 @@ public TClass DeserializeClass(BsonDeserializationContext context)
                     var memberMap = allMemberMaps[memberMapIndex];
                     if (memberMapIndex != extraElementsMemberMapIndex)
                     {
-                        if (_isReferenceType && document != null)
+                        if (document != null)
                         {
                             if (memberMap.IsReadOnly)
                             {
@@ -193,7 +180,7 @@ public TClass DeserializeClass(BsonDeserializationContext context)
                     }
                     else
                     {
-                        if (_isReferenceType && document != null)
+                        if (document != null)
                         {
                             DeserializeExtraElementMember(context, document, elementName, memberMap);
                         }
@@ -215,7 +202,7 @@ public TClass DeserializeClass(BsonDeserializationContext context)
                     if (extraElementsMemberMapIndex >= 0)
                     {
                         var extraElementsMemberMap = _classMap.ExtraElementsMemberMap;
-                        if (_isReferenceType && document != null)
+                        if (document != null)
                         {
                             DeserializeExtraElementMember(context, document, elementName, extraElementsMemberMap);
                         }
@@ -267,7 +254,7 @@ public TClass DeserializeClass(BsonDeserializationContext context)
                             throw new FormatException(message);
                         }
 
-                        if (_isReferenceType && document != null)
+                        if (document != null)
                         {
                             memberMap.ApplyDefaultValue(document);
                         }
@@ -289,18 +276,16 @@ public TClass DeserializeClass(BsonDeserializationContext context)
                 }
             }
 
-            if (_isReferenceType && document != null)
+            if (document != null)
             {
                 if (supportsInitialization != null)
                 {
                     supportsInitialization.EndInit();
                 }
-                return document;
-            }
-            else
-            {
-                return CreateInstanceUsingCreator(values);
+                return (TClass)document;
             }
+
+            return CreateInstanceUsingCreator(values);
         }
 
         /// <summary>
@@ -372,20 +357,18 @@ public override void Serialize(BsonSerializationContext context, BsonSerializati
             if (value == null)
             {
                 bsonWriter.WriteNull();
+                return;
             }
-            else
+
+            var actualType = value.GetType();
+            if (actualType == typeof(TClass))
             {
-                var actualType = value.GetType();
-                if (actualType == typeof(TClass))
-                {
-                    SerializeClass(context, args, value);
-                }
-                else
-                {
-                    var serializer = BsonSerializer.LookupSerializer(actualType);
-                    serializer.Serialize(context, args, value);
-                }
+                SerializeClass(context, args, value);
+                return;
             }
+
+            var serializer = BsonSerializer.LookupSerializer(actualType);
+            serializer.Serialize(context, args, value);
         }
 
         /// <summary>
@@ -433,14 +416,7 @@ private BsonCreatorMap ChooseBestCreator(Dictionary<string, object> values)
         private TClass CreateInstanceUsingCreator(Dictionary<string, object> values)
         {
             var creatorMap = ChooseBestCreator(values);
-            var document = creatorMap.CreateInstance(values); // removes values consumed
-
-            if (values.Count > 0 && _isValueType)
-            {
-                var message = string.Format("Value class {0} cannot be deserialized unless all values can be passed to a constructor.", _classMap.ClassType.FullName);
-                throw new BsonSerializationException(message);
-            }
-
+            object document = creatorMap.CreateInstance(values); // removes values consumed
             var supportsInitialization = document as ISupportInitialize;
             if (supportsInitialization != null)
             {
@@ -473,8 +449,6 @@ private void DeserializeExtraElementMember(
             string elementName,
             BsonMemberMap extraElementsMemberMap)
         {
-            var bsonReader = context.Reader;
-
             if (extraElementsMemberMap.MemberType == typeof(BsonDocument))
             {
                 var extraElements = (BsonDocument)extraElementsMemberMap.Getter(obj);
@@ -514,8 +488,6 @@ private void DeserializeExtraElementValue(
             string elementName,
             BsonMemberMap extraElementsMemberMap)
         {
-            var bsonReader = context.Reader;
-
             if (extraElementsMemberMap.MemberType == typeof(BsonDocument))
             {
                 BsonDocument extraElements;
@@ -561,8 +533,6 @@ private void DeserializeExtraElementValue(
 
         private object DeserializeMemberValue(BsonDeserializationContext context, BsonMemberMap memberMap)
         {
-            var bsonReader = context.Reader;
-
             try
             {
                 return memberMap.GetSerializer().Deserialize(context);
diff --git a/tests/MongoDB.Driver.Legacy.Tests/Jira/CSharp218Tests.cs b/tests/MongoDB.Driver.Legacy.Tests/Jira/CSharp218Tests.cs
@@ -13,10 +13,7 @@
 * limitations under the License.
 */
 
-using System;
-using System.IO;
 using MongoDB.Bson;
-using MongoDB.Driver;
 using Xunit;
 
 namespace MongoDB.Driver.Tests.Jira.CSharp218
@@ -49,32 +46,26 @@ public CSharp218Tests()
         }
 
         [Fact]
-        public void TestDeserializeClassWithStructPropertyWithoutConstructorFails()
+        public void TestDeserializeClassWithStructPropertyWithoutConstructorSucceeds()
         {
             _collection.RemoveAll();
             var c = new C { Id = ObjectId.GenerateNewId(), P = new P { X = 1, Y = 2 } };
             _collection.Insert(c);
-            try
-            {
-                _collection.FindOneAs<C>();
-                Assert.True(false, "Expected an exception to be thrown.");
-            }
-            catch (Exception ex)
-            {
-                var expectedMessage = "An error occurred while deserializing the P field of class MongoDB.Driver.Tests.Jira.CSharp218.CSharp218Tests+C: Value class MongoDB.Driver.Tests.Jira.CSharp218.CSharp218Tests+P cannot be deserialized without a constructor.";
-                Assert.IsType<FormatException>(ex);
-                Assert.IsType<BsonSerializationException>(ex.InnerException);
-                Assert.Equal(expectedMessage, ex.Message);
-            }
+
+            var result = _collection.FindOneAs<C>();
+            Assert.Equal(1, result.P.X);
+            Assert.Equal(2, result.P.Y);
         }
 
         [Fact]
-        public void TestDeserializeStructFails()
+        public void TestDeserializeStructSucceeds()
         {
             _collection.RemoveAll();
             var s = new S { Id = ObjectId.GenerateNewId(), P = new P { X = 1, Y = 2 } };
             _collection.Insert(s);
-            Assert.Throws<BsonSerializationException>(() => _collection.FindOneAs<S>());
+            var result = _collection.FindOneAs<S>();
+            Assert.Equal(1, result.P.X);
+            Assert.Equal(2, result.P.Y);
         }
 
         [Fact]
diff --git a/tests/MongoDB.Driver.Tests/Linq/Linq3ImplementationTests/Jira/CSharp4391Tests.cs b/tests/MongoDB.Driver.Tests/Linq/Linq3ImplementationTests/Jira/CSharp4391Tests.cs
@@ -65,25 +65,27 @@ public void Deserializing_struct_with_constructor_should_work()
         }
 
         [Fact]
-        public void Deserializing_struct_with_partial_constructor_should_fail()
+        public void Deserializing_struct_with_partial_constructor_should_work()
         {
             var json = "{ _id : 1, X : 2, Y : 3 }";
 
-            var expection = Record.Exception(() => { _ = BsonSerializer.Deserialize<T>(json); });
+            var result = BsonSerializer.Deserialize<T>(json);
 
-            expection.Should().BeOfType<BsonSerializationException>();
-            expection.Message.Should().Contain("cannot be deserialized unless all values can be passed to a constructor");
+            result.Id.Should().Be(1);
+            result.X.Should().Be(2);
+            result.Y.Should().Be(3);
         }
 
         [Fact]
-        public void Deserializing_struct_with_no_constructor_should_fail()
+        public void Deserializing_struct_with_no_constructor_should_work()
         {
             var json = "{ _id : 1, X : 2, Y : 3 }";
 
-            var expection = Record.Exception(() => { _ = BsonSerializer.Deserialize<U>(json); });
+            var result = BsonSerializer.Deserialize<U>(json);
 
-            expection.Should().BeOfType<BsonSerializationException>();
-            expection.Message.Should().Contain("cannot be deserialized without a constructor");
+            result.Id.Should().Be(1);
+            result.X.Should().Be(2);
+            result.Y.Should().Be(3);
         }
 
         [Fact]
diff --git a/tests/MongoDB.Driver.Tests/Linq/Linq3ImplementationTests/Translators/ExpressionToAggregationExpressionTranslators/MemberInitExpressionToAggregationExpressionTranslatorTests.cs b/tests/MongoDB.Driver.Tests/Linq/Linq3ImplementationTests/Translators/ExpressionToAggregationExpressionTranslators/MemberInitExpressionToAggregationExpressionTranslatorTests.cs
@@ -189,15 +189,6 @@ public struct SpawnDataStructParameterless
             public int Identifier;
             public DateTime SpawnDate;
             public string SpawnText;
-
-            // this constructor is required to be able to deserialize instances of this struct
-            [BsonConstructor]
-            public SpawnDataStructParameterless(int identifier, DateTime spawnDate, string spawnText)
-            {
-                Identifier = identifier;
-                SpawnDate = spawnDate;
-                SpawnText = spawnText;
-            }
         }
 
         public class SpawnDataClass

Original file line number	Diff line number	Diff line change
`@@ -30,8 +30,6 @@ public class BsonClassMapSerializer<TClass> : SerializerBase<TClass>, IBsonIdPro`
`30`	`30`	`{`
`31`	`31`	`// private fields`
`32`	`32`	`private readonly BsonClassMap _classMap;`
`33`		`- private readonly bool _isReferenceType;`
`34`		`- private readonly bool _isValueType;`
`35`	`33`
`36`	`34`	`// constructors`
`37`	`35`	`/// <summary>`
`@@ -42,21 +40,19 @@ public BsonClassMapSerializer(BsonClassMap classMap)`
`42`	`40`	`{`
`43`	`41`	`if (classMap == null)`
`44`	`42`	`{`
`45`		`- throw new ArgumentNullException("classMap");`
	`43`	`+ throw new ArgumentNullException(nameof(classMap));`
`46`	`44`	`}`
`47`	`45`	`if (classMap.ClassType != typeof(TClass))`
`48`	`46`	`{`
`49`	`47`	`var message = string.Format("Must be a BsonClassMap for the type {0}.", typeof(TClass));`
`50`		`- throw new ArgumentException(message, "classMap");`
	`48`	`+ throw new ArgumentException(message, nameof(classMap));`
`51`	`49`	`}`
`52`	`50`	`if (!classMap.IsFrozen)`
`53`	`51`	`{`
`54`	`52`	`throw new ArgumentException("Class map is not frozen.", nameof(classMap));`
`55`	`53`	`}`
`56`	`54`
`57`	`55`	`_classMap = classMap;`
`58`		`- _isValueType = _classMap.ClassType.IsValueType;`
`59`		`- _isReferenceType = !_isValueType;`
`60`	`56`	`}`
`61`	`57`
`62`	`58`	`// public properties`
`@@ -87,22 +83,17 @@ public override TClass Deserialize(BsonDeserializationContext context, BsonDeser`
`87`	`83`	`bsonReader.ReadNull();`
`88`	`84`	`return default(TClass);`
`89`	`85`	`}`
`90`		`- else`
`91`		`- {`
`92`		`- var discriminatorConvention = _classMap.GetDiscriminatorConvention();`
`93`	`86`
`94`		`- var actualType = discriminatorConvention.GetActualType(bsonReader, args.NominalType);`
`95`		`- if (actualType == typeof(TClass))`
`96`		`- {`
`97`		`- return DeserializeClass(context);`
`98`		`- }`
`99`		`- else`
`100`		`- {`
`101`		`- var serializer = BsonSerializer.LookupSerializer(actualType);`
`102`		`- return (TClass)serializer.Deserialize(context);`
`103`		`- }`
	`87`	`+ var discriminatorConvention = _classMap.GetDiscriminatorConvention();`
`104`	`88`
	`89`	`+ var actualType = discriminatorConvention.GetActualType(bsonReader, args.NominalType);`
	`90`	`+ if (actualType == typeof(TClass))`
	`91`	`+ {`
	`92`	`+ return DeserializeClass(context);`
`105`	`93`	`}`
	`94`	`+`
	`95`	`+ var serializer = BsonSerializer.LookupSerializer(actualType);`
	`96`	`+ return (TClass)serializer.Deserialize(context);`
`106`	`97`	`}`
`107`	`98`
`108`	`99`	`/// <summary>`
`@@ -124,7 +115,9 @@ public TClass DeserializeClass(BsonDeserializationContext context)`
`124`	`115`	`}`
`125`	`116`
`126`	`117`	`Dictionary<string, object> values = null;`
`127`		`- var document = default(TClass);`
	`118`	`+ // Important for struct support:`
	`119`	`+ // should use object variable here, so created value should be boxed right away!`
	`120`	`+ object document = null;`
`128`	`121`
`129`	`122`	`ISupportInitialize supportsInitialization = null;`
`130`	`123`	`if (_classMap.HasCreatorMaps)`
`@@ -135,13 +128,7 @@ public TClass DeserializeClass(BsonDeserializationContext context)`
`135`	`128`	`else`
`136`	`129`	`{`
`137`	`130`	`// for mutable classes we deserialize the values directly into the result object`
`138`		`- if (_isValueType)`
`139`		`- {`
`140`		`- var message = string.Format("Value class {0} cannot be deserialized without a constructor.", _classMap.ClassType.FullName);`
`141`		`- throw new BsonSerializationException(message);`
`142`		`- }`
`143`		`-`
`144`		`- document = (TClass)_classMap.CreateInstance();`
	`131`	`+ document = _classMap.CreateInstance();`
`145`	`132`
`146`	`133`	`if (document == null)`
`147`	`134`	`{`
`@@ -173,7 +160,7 @@ public TClass DeserializeClass(BsonDeserializationContext context)`
`173`	`160`	`var memberMap = allMemberMaps[memberMapIndex];`
`174`	`161`	`if (memberMapIndex != extraElementsMemberMapIndex)`
`175`	`162`	`{`
`176`		`- if (_isReferenceType && document != null)`
	`163`	`+ if (document != null)`
`177`	`164`	`{`
`178`	`165`	`if (memberMap.IsReadOnly)`
`179`	`166`	`{`
`@@ -193,7 +180,7 @@ public TClass DeserializeClass(BsonDeserializationContext context)`
`193`	`180`	`}`
`194`	`181`	`else`
`195`	`182`	`{`
`196`		`- if (_isReferenceType && document != null)`
	`183`	`+ if (document != null)`
`197`	`184`	`{`
`198`	`185`	`DeserializeExtraElementMember(context, document, elementName, memberMap);`
`199`	`186`	`}`
`@@ -215,7 +202,7 @@ public TClass DeserializeClass(BsonDeserializationContext context)`
`215`	`202`	`if (extraElementsMemberMapIndex >= 0)`
`216`	`203`	`{`
`217`	`204`	`var extraElementsMemberMap = _classMap.ExtraElementsMemberMap;`
`218`		`- if (_isReferenceType && document != null)`
	`205`	`+ if (document != null)`
`219`	`206`	`{`
`220`	`207`	`DeserializeExtraElementMember(context, document, elementName, extraElementsMemberMap);`
`221`	`208`	`}`
`@@ -267,7 +254,7 @@ public TClass DeserializeClass(BsonDeserializationContext context)`
`267`	`254`	`throw new FormatException(message);`
`268`	`255`	`}`
`269`	`256`
`270`		`- if (_isReferenceType && document != null)`
	`257`	`+ if (document != null)`
`271`	`258`	`{`
`272`	`259`	`memberMap.ApplyDefaultValue(document);`
`273`	`260`	`}`
`@@ -289,18 +276,16 @@ public TClass DeserializeClass(BsonDeserializationContext context)`
`289`	`276`	`}`
`290`	`277`	`}`
`291`	`278`
`292`		`- if (_isReferenceType && document != null)`
	`279`	`+ if (document != null)`
`293`	`280`	`{`
`294`	`281`	`if (supportsInitialization != null)`
`295`	`282`	`{`
`296`	`283`	`supportsInitialization.EndInit();`
`297`	`284`	`}`
`298`		`- return document;`
`299`		`- }`
`300`		`- else`
`301`		`- {`
`302`		`- return CreateInstanceUsingCreator(values);`
	`285`	`+ return (TClass)document;`
`303`	`286`	`}`
	`287`	`+`
	`288`	`+ return CreateInstanceUsingCreator(values);`
`304`	`289`	`}`
`305`	`290`
`306`	`291`	`/// <summary>`
`@@ -372,20 +357,18 @@ public override void Serialize(BsonSerializationContext context, BsonSerializati`
`372`	`357`	`if (value == null)`
`373`	`358`	`{`
`374`	`359`	`bsonWriter.WriteNull();`
	`360`	`+ return;`
`375`	`361`	`}`
`376`		`- else`
	`362`	`+`
	`363`	`+ var actualType = value.GetType();`
	`364`	`+ if (actualType == typeof(TClass))`
`377`	`365`	`{`
`378`		`- var actualType = value.GetType();`
`379`		`- if (actualType == typeof(TClass))`
`380`		`- {`
`381`		`- SerializeClass(context, args, value);`
`382`		`- }`
`383`		`- else`
`384`		`- {`
`385`		`- var serializer = BsonSerializer.LookupSerializer(actualType);`
`386`		`- serializer.Serialize(context, args, value);`
`387`		`- }`
	`366`	`+ SerializeClass(context, args, value);`
	`367`	`+ return;`
`388`	`368`	`}`
	`369`	`+`
	`370`	`+ var serializer = BsonSerializer.LookupSerializer(actualType);`
	`371`	`+ serializer.Serialize(context, args, value);`
`389`	`372`	`}`
`390`	`373`
`391`	`374`	`/// <summary>`
`@@ -433,14 +416,7 @@ private BsonCreatorMap ChooseBestCreator(Dictionary<string, object> values)`
`433`	`416`	`private TClass CreateInstanceUsingCreator(Dictionary<string, object> values)`
`434`	`417`	`{`
`435`	`418`	`var creatorMap = ChooseBestCreator(values);`
`436`		`- var document = creatorMap.CreateInstance(values); // removes values consumed`
`437`		`-`
`438`		`- if (values.Count > 0 && _isValueType)`
`439`		`- {`
`440`		`- var message = string.Format("Value class {0} cannot be deserialized unless all values can be passed to a constructor.", _classMap.ClassType.FullName);`
`441`		`- throw new BsonSerializationException(message);`
`442`		`- }`
`443`		`-`
	`419`	`+ object document = creatorMap.CreateInstance(values); // removes values consumed`
`444`	`420`	`var supportsInitialization = document as ISupportInitialize;`
`445`	`421`	`if (supportsInitialization != null)`
`446`	`422`	`{`
`@@ -473,8 +449,6 @@ private void DeserializeExtraElementMember(`
`473`	`449`	`string elementName,`
`474`	`450`	`BsonMemberMap extraElementsMemberMap)`
`475`	`451`	`{`
`476`		`- var bsonReader = context.Reader;`
`477`		`-`
`478`	`452`	`if (extraElementsMemberMap.MemberType == typeof(BsonDocument))`
`479`	`453`	`{`
`480`	`454`	`var extraElements = (BsonDocument)extraElementsMemberMap.Getter(obj);`
`@@ -514,8 +488,6 @@ private void DeserializeExtraElementValue(`
`514`	`488`	`string elementName,`
`515`	`489`	`BsonMemberMap extraElementsMemberMap)`
`516`	`490`	`{`
`517`		`- var bsonReader = context.Reader;`
`518`		`-`
`519`	`491`	`if (extraElementsMemberMap.MemberType == typeof(BsonDocument))`
`520`	`492`	`{`
`521`	`493`	`BsonDocument extraElements;`
`@@ -561,8 +533,6 @@ private void DeserializeExtraElementValue(`
`561`	`533`
`562`	`534`	`private object DeserializeMemberValue(BsonDeserializationContext context, BsonMemberMap memberMap)`
`563`	`535`	`{`
`564`		`- var bsonReader = context.Reader;`
`565`		`-`
`566`	`536`	`try`
`567`	`537`	`{`
`568`	`538`	`return memberMap.GetSerializer().Deserialize(context);`
Original file line number	Diff line number	Diff line change
`@@ -65,25 +65,27 @@ public void Deserializing_struct_with_constructor_should_work()`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`[Fact]`
`68`		`- public void Deserializing_struct_with_partial_constructor_should_fail()`
	`68`	`+ public void Deserializing_struct_with_partial_constructor_should_work()`
`69`	`69`	`{`
`70`	`70`	`var json = "{ _id : 1, X : 2, Y : 3 }";`
`71`	`71`
`72`		`- var expection = Record.Exception(() => { _ = BsonSerializer.Deserialize<T>(json); });`
	`72`	`+ var result = BsonSerializer.Deserialize<T>(json);`
`73`	`73`
`74`		`- expection.Should().BeOfType<BsonSerializationException>();`
`75`		`- expection.Message.Should().Contain("cannot be deserialized unless all values can be passed to a constructor");`
	`74`	`+ result.Id.Should().Be(1);`
	`75`	`+ result.X.Should().Be(2);`
	`76`	`+ result.Y.Should().Be(3);`
`76`	`77`	`}`
`77`	`78`
`78`	`79`	`[Fact]`
`79`		`- public void Deserializing_struct_with_no_constructor_should_fail()`
	`80`	`+ public void Deserializing_struct_with_no_constructor_should_work()`
`80`	`81`	`{`
`81`	`82`	`var json = "{ _id : 1, X : 2, Y : 3 }";`
`82`	`83`
`83`		`- var expection = Record.Exception(() => { _ = BsonSerializer.Deserialize<U>(json); });`
	`84`	`+ var result = BsonSerializer.Deserialize<U>(json);`
`84`	`85`
`85`		`- expection.Should().BeOfType<BsonSerializationException>();`
`86`		`- expection.Message.Should().Contain("cannot be deserialized without a constructor");`
	`86`	`+ result.Id.Should().Be(1);`
	`87`	`+ result.X.Should().Be(2);`
	`88`	`+ result.Y.Should().Be(3);`
`87`	`89`	`}`
`88`	`90`
`89`	`91`	`[Fact]`