WindowsAzure.Table.Queryable.Expressions.Methods.SelectTranslator.Translate C# (CSharp) Method

        public void Translate(MethodCallExpression method, ITranslationResult result)
        {
            if (method.Method.Name != MethodName || method.Arguments.Count != 2)
            {
                var message = string.Format(Resources.TranslatorMethodNotSupported, method.Method.Name);
                throw new ArgumentOutOfRangeException(nameof(method), message);
            }

            var lambda = (LambdaExpression) ExpressionTranslator.StripQuotes(method.Arguments[1]);

            // ReSharper disable ForCanBeConvertedToForeach

            if (lambda.Body.NodeType == ExpressionType.MemberInit)
            {
                var memberInit = (MemberInitExpression) lambda.Body;

                for (int i = 0; i < memberInit.Bindings.Count; i++)
                {
                    MemberBinding binding = memberInit.Bindings[i];
                    AddColumn(binding.Member.Name, result);
                }
            }
            else if (lambda.Body.NodeType == ExpressionType.New)
            {
                var newInstance = (NewExpression) lambda.Body;

                for (int i = 0; i < newInstance.Arguments.Count; i++)
                {
                    Expression argument = newInstance.Arguments[i];
                    var member = (MemberExpression) argument;
                    AddColumn(member.Member.Name, result);
                }
            }
            else
            {
                throw new NotSupportedException(string.Format(Resources.TranslatorMemberNotSupported, lambda.Body.NodeType));
            }

            // ReSharper restore ForCanBeConvertedToForeach

            AddPostProcessing(method, result);
        }

        public void LinqSelectWithProjectionClass()
        {
            // Arrange
            IQueryable<ProjectionResult> query = GetQueryable()
                .Select(p => new ProjectionResult {Name = p.Name, Continent = p.Continent, Area = p.Area});
            var translator = new SelectTranslator(_nameChanges);
            var translation = new TranslationResult();

            // Act && Assert
            translator.Translate((MethodCallExpression) query.Expression, translation);

            Assert.NotNull(translation.TableQuery);
            Assert.NotNull(translation.TableQuery.SelectColumns);
            Assert.Equal(3, translation.TableQuery.SelectColumns.Count);
            Assert.Contains("PartitionKey", translation.TableQuery.SelectColumns);
            Assert.Contains("RowKey", translation.TableQuery.SelectColumns);
            Assert.Contains("Area", translation.TableQuery.SelectColumns);

            object result = translation.PostProcessing.DynamicInvoke(GetList().AsQueryable());

            Assert.NotNull(result);
            Assert.IsAssignableFrom<IEnumerable<ProjectionResult>>(result);

            List<ProjectionResult> entities = ((IEnumerable<ProjectionResult>) result).ToList();
            IEnumerable<string> names = entities.Select(p => p.Name).ToList();

            Assert.Contains(Germany, names);
            Assert.Contains(Spain, names);
        }