CSHARP-4662: Add an As method for IMongoQueryable similar to the existing As method for aggregation pipelines.

Author: rstam

src/MongoDB.Driver/Linq/Linq3Implementation/Reflection/MongoQueryableMethod.cs

@@ -28,6 +28,7 @@ internal static class MongoQueryableMethod
         private static readonly MethodInfo __anyAsync;
         private static readonly MethodInfo __anyWithPredicateAsync;
         private static readonly MethodInfo __appendStage;
+        private static readonly MethodInfo __as;
         private static readonly MethodInfo __averageDecimalAsync;
         private static readonly MethodInfo __averageDecimalWithSelectorAsync;
         private static readonly MethodInfo __averageDoubleAsync;
@@ -177,6 +178,7 @@ static MongoQueryableMethod()
             __anyAsync = ReflectionInfo.Method((IMongoQueryable<object> source, CancellationToken cancellationToken) => source.AnyAsync(cancellationToken));
             __anyWithPredicateAsync = ReflectionInfo.Method((IMongoQueryable<object> source, Expression<Func<object, bool>> predicate, CancellationToken cancellationToken) => source.AnyAsync(predicate, cancellationToken));
             __appendStage = ReflectionInfo.Method((IMongoQueryable<object> source, PipelineStageDefinition<object, object> stage, IBsonSerializer<object> resultSerializer) => source.AppendStage(stage, resultSerializer));
+            __as = ReflectionInfo.Method((IMongoQueryable<object> source, IBsonSerializer<object> resultSerializer) => source.As(resultSerializer));
             __averageDecimalAsync = ReflectionInfo.Method((IMongoQueryable<decimal> source, CancellationToken cancellationToken) => source.AverageAsync(cancellationToken));
             __averageDecimalWithSelectorAsync = ReflectionInfo.Method((IMongoQueryable<object> source, Expression<Func<object, decimal>> selector, CancellationToken cancellationToken) => source.AverageAsync(selector, cancellationToken));
             __averageDoubleAsync = ReflectionInfo.Method((IMongoQueryable<double> source, CancellationToken cancellationToken) => source.AverageAsync(cancellationToken));
@@ -325,6 +327,7 @@ static MongoQueryableMethod()
         public static MethodInfo AnyAsync => __anyAsync;
         public static MethodInfo AnyWithPredicateAsync => __anyWithPredicateAsync;
         public static MethodInfo AppendStage => __appendStage;
+        public static MethodInfo As => __as;
         public static MethodInfo AverageDecimalAsync => __averageDecimalAsync;
         public static MethodInfo AverageDecimalWithSelectorAsync => __averageDecimalWithSelectorAsync;
         public static MethodInfo AverageDoubleAsync => __averageDoubleAsync;

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToPipelineTranslators/AsMethodToPipelineTranslator.cs

@@ -0,0 +1,52 @@
+/* Copyright 2010-present MongoDB 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.Linq.Expressions;
+using MongoDB.Bson.Serialization;
+using MongoDB.Driver.Linq.Linq3Implementation.Ast;
+using MongoDB.Driver.Linq.Linq3Implementation.Ast.Stages;
+using MongoDB.Driver.Linq.Linq3Implementation.ExtensionMethods;
+using MongoDB.Driver.Linq.Linq3Implementation.Misc;
+using MongoDB.Driver.Linq.Linq3Implementation.Reflection;
+
+namespace MongoDB.Driver.Linq.Linq3Implementation.Translators.ExpressionToPipelineTranslators
+{
+    internal static class AsMethodToPipelineTranslator
+    {
+        // public static methods
+        public static AstPipeline Translate(TranslationContext context, MethodCallExpression expression)
+        {
+            var method = expression.Method;
+            var arguments = expression.Arguments;
+
+            if (method.Is(MongoQueryableMethod.As))
+            {
+                var sourceExpression = ConvertHelper.RemoveConvertToMongoQueryable(arguments[0]);
+                var pipeline = ExpressionToPipelineTranslator.Translate(context, sourceExpression);
+
+                var resultSerializerExpression = arguments[1];
+                var resultSerializer = resultSerializerExpression.GetConstantValue<IBsonSerializer>(expression);
+                var resultType = method.GetGenericArguments()[1];
+                var outputSerializer = resultSerializer ?? BsonSerializer.LookupSerializer(resultType);
+
+                pipeline = pipeline.AddStages(outputSerializer, newStages: Array.Empty<AstStage>());
+                return pipeline;
+            }
+
+            throw new ExpressionNotSupportedException(expression);
+        }
+    }
+}

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToPipelineTranslators/ExpressionToPipelineTranslator.cs

@@ -36,6 +36,8 @@ public static AstPipeline Translate(TranslationContext context, Expression expre
             {
                 case "AppendStage":
                     return AppendStageMethodToPipelineTranslator.Translate(context, methodCallExpression);
+                case "As":
+                    return AsMethodToPipelineTranslator.Translate(context, methodCallExpression);
                 case "Densify":
                     return DensifyMethodToPipelineTranslator.Translate(context, methodCallExpression);
                 case "Distinct":

src/MongoDB.Driver/Linq/MongoQueryable.cs

@@ -21,8 +21,8 @@
 using System.Threading;
 using System.Threading.Tasks;
 using MongoDB.Bson.Serialization;
-using MongoDB.Driver.Search;
 using MongoDB.Driver.Core.Misc;
+using MongoDB.Driver.Search;
 
 namespace MongoDB.Driver.Linq
 {
@@ -100,6 +100,31 @@ public static IMongoQueryable<TResult> AppendStage<TSource, TResult>(
                     Expression.Constant(resultSerializer, typeof(IBsonSerializer<TResult>))));
         }
 
+        /// <summary>
+        /// Allows the results to be interpreted as a different type. It is up to the caller
+        /// to determine that the new result type is compatible with the actual results.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
+        /// <typeparam name="TResult">The new result type for the results.</typeparam>
+        /// <param name="source">A sequence of values.</param>
+        /// <param name="resultSerializer">The new serializer (optional, will be looked up if null).</param>
+        /// <returns>
+        /// A new IMongoQueryable with a new result type.
+        /// </returns>
+        public static IMongoQueryable<TResult> As<TSource, TResult>(
+            this IMongoQueryable<TSource> source,
+            IBsonSerializer<TResult> resultSerializer = null)
+        {
+            Ensure.IsNotNull(source, nameof(source));
+
+            return (IMongoQueryable<TResult>)source.Provider.CreateQuery<TResult>(
+                Expression.Call(
+                    null,
+                    GetMethodInfo(As, source, resultSerializer),
+                    Expression.Convert(source.Expression, typeof(IMongoQueryable<TSource>)),
+                    Expression.Constant(resultSerializer, typeof(IBsonSerializer<TResult>))));
+        }
+
         /// <summary>
         /// Computes the average of a sequence of <see cref="Decimal"/> values.
         /// </summary>

tests/MongoDB.Driver.Tests/Linq/Linq3ImplementationTests/Translators/ExpressionToPipelineTranslators/AsMethodToPipelineTranslatorTests.cs

@@ -0,0 +1,64 @@
+/* Copyright 2010-present MongoDB 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.Linq;
+using FluentAssertions;
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization.Serializers;
+using MongoDB.Driver;
+using MongoDB.Driver.Linq;
+using Xunit;
+
+namespace MongoDB.Driver.Tests.Linq.Linq3ImplementationTests.Translators.ExpressionToPipelineTranslators
+{
+    public class AsMethodToPipelineTranslatorTests : Linq3IntegrationTest
+    {
+        [Fact]
+        public void As_should_work()
+        {
+            var collection = GetCollection();
+
+            var queryable = collection.AsQueryable()
+                .Where(x => x.Name == "John")
+                .As(BsonDocumentSerializer.Instance);
+
+            var stages = Translate(collection, queryable, out var outputSerializer);
+            AssertStages(
+                stages,
+                "{ $match : { Name : 'John' } }");
+            outputSerializer.Should().BeSameAs(BsonDocumentSerializer.Instance);
+
+            var result = queryable.Single();
+            result.Should().BeOfType<BsonDocument>();
+            result.Should().Be("{ _id : 1, Name : 'John' }");
+        }
+
+        private IMongoCollection<C> GetCollection()
+        {
+            var collection = GetCollection<C>("test");
+            CreateCollection(
+                collection,
+                new C { Id = 1, Name = "John" },
+                new C { Id = 2, Name = "Jane" });
+            return collection;
+        }
+
+        private class C
+        {
+            public int Id { get; set; }
+            public string Name { get; set; }
+        }
+    }
+}