CSHARP:1253: Fixed issue with projecting into a derived class.

Conflicts:
	src/MongoDB.Driver/Linq/Processors/SerializerBuilder.cs

Author: craiggwilson

src/MongoDB.Bson/Serialization/BsonClassMap.cs

@@ -29,7 +29,7 @@ namespace MongoDB.Bson.Serialization
     /// <summary>
     /// Represents a mapping between a class and a BSON document.
     /// </summary>
-    public abstract class BsonClassMap
+    public class BsonClassMap
     {
         // private static fields
         private readonly static Dictionary<Type, BsonClassMap> __classMaps = new Dictionary<Type, BsonClassMap>();
@@ -67,7 +67,7 @@ public abstract class BsonClassMap
         /// Initializes a new instance of the BsonClassMap class.
         /// </summary>
         /// <param name="classType">The class type.</param>
-        protected BsonClassMap(Type classType)
+        public BsonClassMap(Type classType)
         {
             _classType = classType;
             _creatorMaps = new List<BsonCreatorMap>();
@@ -81,6 +81,17 @@ protected BsonClassMap(Type classType)
             Reset();
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BsonClassMap"/> class.
+        /// </summary>
+        /// <param name="classType">Type of the class.</param>
+        /// <param name="baseClassMap">The base class map.</param>
+        public BsonClassMap(Type classType, BsonClassMap baseClassMap)
+            : this(classType)
+        {
+            _baseClassMap = baseClassMap;
+        }
+
         // public properties
         /// <summary>
         /// Gets all the member maps (including maps for inherited members).
@@ -448,7 +459,10 @@ public BsonClassMap Freeze()
                         var baseType = _classType.BaseType;
                         if (baseType != null)
                         {
-                            _baseClassMap = LookupClassMap(baseType);
+                            if (_baseClassMap == null)
+                            {
+                                _baseClassMap = LookupClassMap(baseType);
+                            }
                             _discriminatorIsRequired |= _baseClassMap._discriminatorIsRequired;
                             _hasRootClass |= (_isRootClass || _baseClassMap.HasRootClass);
                             _allMemberMaps.AddRange(_baseClassMap.AllMemberMaps);

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

@@ -30,19 +30,24 @@ namespace MongoDB.Bson.Serialization
     public class BsonClassMapSerializer<TClass> : SerializerBase<TClass>, IBsonIdProvider, IBsonDocumentSerializer, IBsonPolymorphicSerializer
     {
         // private fields
-        private BsonClassMap<TClass> _classMap;
+        private BsonClassMap _classMap;
 
         // constructors
         /// <summary>
         /// Initializes a new instance of the BsonClassMapSerializer class.
         /// </summary>
         /// <param name="classMap">The class map.</param>
-        public BsonClassMapSerializer(BsonClassMap<TClass> classMap)
+        public BsonClassMapSerializer(BsonClassMap classMap)
         {
             if (classMap == null)
             {
                 throw new ArgumentNullException("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");
+            }
 
             _classMap = classMap;
         }
@@ -128,7 +133,7 @@ public TClass DeserializeClass(BsonDeserializationContext context)
             else
             {
                 // for mutable classes we deserialize the values directly into the result object
-                document = _classMap.CreateInstance();
+                document = (TClass)_classMap.CreateInstance();
 
                 supportsInitialization = document as ISupportInitialize;
                 if (supportsInitialization != null)

src/MongoDB.Driver.Tests/Linq/Translators/AggregateProjectionTranslatorTests_Project.cs

@@ -744,6 +744,17 @@ public async Task Should_translate_array_projection()
             result.Value.Result.Should().BeEquivalentTo(33, 55);
         }
 
+        [Test]
+        public async Task Should_translate_a_derived_class_projection()
+        {
+            var result = await Project(x => new DerivedRootView { Property = x.A, DerivedProperty = x.B });
+
+            result.Projection.Should().Be("{ Property: \"$A\", DerivedProperty: \"$B\", _id: 0 }");
+
+            result.Value.Property.Should().Be("Awesome");
+            result.Value.DerivedProperty.Should().Be("Balloon");
+        }
+
         [Test]
         [Ignore("MongoDB does something weird with this result. It returns F and H as two separate arrays, not an array of documents")]
         public async Task Should_translate_array_projection_complex()

src/MongoDB.Driver.Tests/Linq/Translators/TranslatorTestBase.cs

@@ -93,6 +93,11 @@ public RootView(string property)
             public string Field = null;
         }
 
+        public class DerivedRootView : RootView
+        {
+            public string DerivedProperty { get; set; }
+        }
+
         public class Root : IRoot
         {
             public int Id { get; set; }

src/MongoDB.Driver/Linq/Translators/AggregateProjectionTranslator.cs

@@ -658,9 +658,39 @@ private IBsonSerializer BuildProjectedSerializer(ProjectionMapping mapping)
                 // the same anonymous type definition in different contexts as long as they 
                 // are structurally equatable. As such, it might be that two different queries 
                 // projecting the same shape might need to be deserialized differently.
-                var classMapType = typeof(BsonClassMap<>).MakeGenericType(mapping.Expression.Type);
-                BsonClassMap classMap = (BsonClassMap)Activator.CreateInstance(classMapType);
-                foreach (var memberMapping in mapping.Members)
+                var classMap = BuildClassMap(mapping.Expression.Type, mapping);
+
+                var mappedParameters = mapping.Members
+                    .Where(x => x.Parameter != null)
+                    .OrderBy(x => x.Parameter.Position)
+                    .Select(x => x.Member)
+                    .ToList();
+
+                if (mappedParameters.Count > 0)
+                {
+                    classMap.MapConstructor(mapping.Constructor)
+                        .SetArguments(mappedParameters);
+                }
+
+                var serializerType = typeof(BsonClassMapSerializer<>).MakeGenericType(mapping.Expression.Type);
+                return (IBsonSerializer)Activator.CreateInstance(serializerType, classMap.Freeze());
+            }
+
+            private BsonClassMap BuildClassMap(Type type, ProjectionMapping mapping)
+            {
+                if (type == null || type == typeof(object))
+                {
+                    return null;
+                }
+
+                var baseClassMap = BuildClassMap(type.BaseType, mapping);
+                if (baseClassMap != null)
+                {
+                    baseClassMap.Freeze();
+                }
+                var classMap = new BsonClassMap(type, baseClassMap);
+
+                foreach (var memberMapping in mapping.Members.Where(x => x.Member.DeclaringType == type))
                 {
                     var serializationExpression = memberMapping.Expression as ISerializationExpression;
                     if (serializationExpression == null)
@@ -685,20 +715,7 @@ private IBsonSerializer BuildProjectedSerializer(ProjectionMapping mapping)
                     }
                 }
 
-                var mappedParameters = mapping.Members
-                    .Where(x => x.Parameter != null)
-                    .OrderBy(x => x.Parameter.Position)
-                    .Select(x => x.Member)
-                    .ToList();
-
-                if (mappedParameters.Count > 0)
-                {
-                    classMap.MapConstructor(mapping.Constructor)
-                        .SetArguments(mappedParameters);
-                }
-
-                var serializerType = typeof(BsonClassMapSerializer<>).MakeGenericType(mapping.Expression.Type);
-                return (IBsonSerializer)Activator.CreateInstance(serializerType, classMap.Freeze());
+                return classMap;
             }
         }