CSHARP-1826: Map immutable classes correctly.

Author: rstam

src/MongoDB.Bson/Serialization/Conventions/ImmutableTypeClassMapConvention.cs

@@ -39,28 +39,45 @@ public void Apply(BsonClassMap classMap)
                 return;
             }
 
+            var properties = typeInfo.GetProperties();
+            if (properties.Any(p => p.CanWrite))
+            {
+                return; // a type that has any writable properties is not immutable
+            }
+
+            var anyConstructorsWereMapped = false;
             foreach (var ctor in typeInfo.GetConstructors())
             {
                 var parameters = ctor.GetParameters();
-                var properties = typeInfo.GetProperties();
                 if (parameters.Length != properties.Length)
                 {
-                    continue;
+                    continue; // only consider constructors that have sufficient parameters to initialize all properties
                 }
 
                 var matches = parameters
                     .GroupJoin(properties,
                         parameter => parameter.Name,
                         property => property.Name,
-                        (parameter, props) => new { parameter, properties = props },
+                        (parameter, props) => new { Parameter = parameter, Properties = props },
                         StringComparer.OrdinalIgnoreCase);
 
-                if (matches.Any(m => m.properties.Count() != 1 || m.properties.ElementAt(0).CanWrite))
+                if (matches.Any(m => m.Properties.Count() != 1))
                 {
                     continue;
                 }
 
                 classMap.MapConstructor(ctor);
+
+                anyConstructorsWereMapped = true;
+            }
+
+            if (anyConstructorsWereMapped)
+            {
+                // if any constructors were mapped by this convention then map all the properties also
+                foreach (var property in properties)
+                {
+                    classMap.MapMember(property);
+                }
             }
         }
     }

src/MongoDB.Bson/Serialization/Conventions/ReadWriteMemberFinderConvention.cs

@@ -104,9 +104,9 @@ private void MapField(BsonClassMap classMap, FieldInfo fieldInfo)
 
         private void MapProperty(BsonClassMap classMap, PropertyInfo propertyInfo)
         {
-            if (!propertyInfo.CanRead || (!propertyInfo.CanWrite && classMap.ClassType.Namespace != null))
+            if (!propertyInfo.CanRead || !propertyInfo.CanWrite)
             {
-                // we can't write or it is anonymous...
+                // only read and write properties are mapped
                 return;
             }
 

tests/MongoDB.Bson.Tests/Serialization/Conventions/ImmutableTypeClassMapConventionTests.cs

@@ -1,4 +1,4 @@
-/* Copyright 2010-2014 MongoDB Inc.
+/* Copyright 2010-2016 MongoDB Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -15,6 +15,7 @@
 
 using System;
 using System.Linq;
+using FluentAssertions;
 using MongoDB.Bson;
 using MongoDB.Bson.Serialization;
 using MongoDB.Bson.Serialization.Conventions;
@@ -59,6 +60,43 @@ public TestClassC(string a, string b)
             }
         }
 
+        [Fact]
+        public void Anonymous_class_should_map_correctly()
+        {
+            var c = new { A = 1, B = 2 };
+            var classMap = BsonClassMap.LookupClassMap(c.GetType());
+
+            classMap.DeclaredMemberMaps.Select(m => m.MemberName).Should().Equal("A", "B");
+            classMap.CreatorMaps.Count().Should().Be(1);
+        }
+
+        [Fact]
+        public void TestClassA_should_map_correctly()
+        {
+            var classMap = BsonClassMap.LookupClassMap(typeof(TestClassA));
+
+            classMap.DeclaredMemberMaps.Select(m => m.MemberName).Should().Equal("A", "B");
+            classMap.CreatorMaps.Count().Should().Be(0);
+        }
+
+        [Fact]
+        public void TestClassB_should_map_correctly()
+        {
+            var classMap = BsonClassMap.LookupClassMap(typeof(TestClassB));
+
+            classMap.DeclaredMemberMaps.Select(m => m.MemberName).Should().Equal("A", "B");
+            classMap.CreatorMaps.Count().Should().Be(1);
+        }
+
+        [Fact]
+        public void TestClassC_should_map_correctly()
+        {
+            var classMap = BsonClassMap.LookupClassMap(typeof(TestClassC));
+
+            classMap.DeclaredMemberMaps.Select(m => m.MemberName).Should().Equal("A", "B");
+            classMap.CreatorMaps.Count().Should().Be(1);
+        }
+
         [Fact]
         public void TestNoDefaultConstructorClassMapConventionWithTestClassA()
         {