CSHARP-538: fixed bug related to element selection after projections.

Author: craiggwilson

Driver/Linq/Translators/Projector.cs

@@ -21,12 +21,83 @@
 
 namespace MongoDB.Driver.Linq
 {
+    /// <summary>
+    /// Represents a projection from TSource to TResult;
+    /// </summary>
+    internal interface IProjector : IEnumerable
+    {
+        /// <summary>
+        /// Gets the cursor.
+        /// </summary>
+        MongoCursor Cursor { get; }
+    }
+
+    /// <summary>
+    /// Represents a projection from TSource to TResult;
+    /// </summary>
+    /// <typeparam name="TSource">The type of the source.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    internal interface IProjector<TSource, TResult> : IProjector, IEnumerable<TResult>
+    { }
+
+    /// <summary>
+    /// Represents a projector that does nothing.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    internal class IdentityProjector<T> : IProjector<T,T>
+    {
+        // private fields
+        private readonly MongoCursor _cursor;
+
+        // constructors
+        /// <summary>
+        /// Initializes a new instance of the <see cref="IdentityProjector&lt;T&gt;"/> class.
+        /// </summary>
+        /// <param name="cursor">The cursor.</param>
+        public IdentityProjector(MongoCursor cursor)
+        {
+            _cursor = cursor;
+        }
+
+        // public properties
+        /// <summary>
+        /// Gets the cursor.
+        /// </summary>
+        public MongoCursor Cursor
+        {
+            get { return _cursor; }
+        }
+
+        // public methods
+        /// <summary>
+        /// Returns an enumerator that iterates through the collection.
+        /// </summary>
+        /// <returns>
+        /// A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection.
+        /// </returns>
+        public IEnumerator<T> GetEnumerator()
+        {
+            return ((IEnumerable<T>)_cursor).GetEnumerator();
+        }
+
+        /// <summary>
+        /// Returns an enumerator that iterates through a collection.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection.
+        /// </returns>
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+
     /// <summary>
     /// Represents a projection.
     /// </summary>
     /// <typeparam name="TSource">The type of the source objects.</typeparam>
     /// <typeparam name="TResult">The type of the result objects.</typeparam>
-    public class Projector<TSource, TResult> : IEnumerable<TResult>
+    internal class Projector<TSource, TResult> : IProjector<TSource, TResult>
     {
         // private fields
         private MongoCursor<TSource> _cursor;
@@ -44,17 +115,23 @@ public Projector(MongoCursor<TSource> cursor, Func<TSource, TResult> projection)
             _projection = projection;
         }
 
+        // public properties
+        /// <summary>
+        /// Gets the cursor.
+        /// </summary>
+        public MongoCursor Cursor
+        {
+            get { return _cursor; }
+        }
+
         // public methods
         /// <summary>
         /// Gets an enumerator for the result objects.
         /// </summary>
         /// <returns>An enumerator for the result objects.</returns>
         public IEnumerator<TResult> GetEnumerator()
         {
-            foreach (var document in _cursor)
-            {
-                yield return _projection(document);
-            }
+            return _cursor.Select(_projection).GetEnumerator();
         }
 
         // explicit interface implementation

Driver/Linq/Translators/SelectQuery.cs

@@ -188,10 +188,11 @@ public override object Execute()
                 }
             }
 
-            IEnumerable enumerable;
+            IProjector projector;
             if (projection == null)
             {
-                enumerable = cursor;
+                var projectorType = typeof(IdentityProjector<>).MakeGenericType(DocumentType);
+                projector = (IProjector)Activator.CreateInstance(projectorType, cursor);
             }
             else
             {
@@ -201,17 +202,16 @@ public override object Execute()
                 var resultType = delegateType.GetGenericArguments()[1];
                 var projectorType = typeof(Projector<,>).MakeGenericType(sourceType, resultType);
                 var compiledProjection = projection.Compile();
-                var projector = Activator.CreateInstance(projectorType, cursor, compiledProjection);
-                enumerable = (IEnumerable)projector;
+                projector = (IProjector)Activator.CreateInstance(projectorType, cursor, compiledProjection);
             }
 
             if (_elementSelector != null)
             {
-                return _elementSelector(enumerable);
+                return _elementSelector(projector);
             }
             else
             {
-                return enumerable;
+                return projector;
             }
         }
 
@@ -388,7 +388,7 @@ private void TranslateAny(MethodCallExpression methodCallExpression)
             _projection = null;
 
             // note: recall that cursor method Size respects Skip and Limit while Count does not
-            SetElementSelector(methodCallExpression, source => ((int)((MongoCursor)source).Size()) > 0);
+            SetElementSelector(methodCallExpression, source => ((int)((IProjector)source).Cursor.Size()) > 0);
         }
 
         private void TranslateCount(MethodCallExpression methodCallExpression)
@@ -413,10 +413,10 @@ private void TranslateCount(MethodCallExpression methodCallExpression)
             switch (methodCallExpression.Method.Name)
             {
                 case "Count":
-                    SetElementSelector(methodCallExpression, source => (int)((MongoCursor)source).Size());
+                    SetElementSelector(methodCallExpression, source => (int)((IProjector)source).Cursor.Size());
                     break;
                 case "LongCount":
-                    SetElementSelector(methodCallExpression, source => ((MongoCursor)source).Size());
+                    SetElementSelector(methodCallExpression, source => ((IProjector)source).Cursor.Size());
                     break;
             }
         }

DriverUnitTests/DriverUnitTests.csproj

@@ -128,6 +128,7 @@
     <Compile Include="GridFS\MongoGridFSSettingsTests.cs" />
     <Compile Include="GridFS\MongoGridFSStreamTests.cs" />
     <Compile Include="GridFS\MongoGridFSTests.cs" />
+    <Compile Include="Jira\CSharp538Tests.cs" />
     <Compile Include="Jira\CSharp532Tests.cs" />
     <Compile Include="Jira\CSharp475Tests.cs" />
     <Compile Include="Jira\CSharp101Tests.cs" />

DriverUnitTests/Jira/CSharp538Tests.cs

@@ -0,0 +1,54 @@
+/* Copyright 2010-2012 10gen Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+
+using MongoDB.Bson;
+using MongoDB.Driver;
+using MongoDB.Driver.Linq;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDB.Driver.Builders;
+
+namespace MongoDB.DriverUnitTests.Jira.CSharp538
+{
+    [TestFixture]
+    public class CSharp538Tests
+    {
+        [BsonKnownTypes(typeof(B))]
+        public abstract class A
+        {
+
+        }
+
+        public class B : A
+        {
+
+        }
+
+        [Test]
+        public void Test()
+        {
+            var db = Configuration.TestDatabase;
+            var collection = db.GetCollection<A>("csharp_538");
+
+            var count = collection.AsQueryable().OfType<B>().Count();
+            Assert.AreEqual(0, count);
+        }
+    }
+}