using System;

using System.Collections.Generic;

using System.Linq;

using System.Linq.Expressions;

using System.Reflection;

using LatticeUtils;

using Type = System.Type;

​

public class Program

{

    public static void Main()

    {

        var list = new[] {new Foo 

        { 

            Property1 = "foo1",

            Bar = new Bar{Prop1="AA",Prop2="Bb"} ,

            Bars =new List<Bar>(){ new Bar{Prop1="AA",Prop2="Bb"} }

        },

                          new Foo {

                              Property1 = "foo2",Property2="a",Bar= new Bar{Prop1="AA",Prop2="Bb"}  }};

        var result = list

            .Select(x=>new{

            Property1 = x.Property1,

            Property2 = x.Property2,

            Bar = x.Bar.SelectDynamic("Prop1")

            })

            .SelectDynamic("Property1","Bar");

        result.Dump();

    }

}

​

public class Foo

{

    public string Property1 {get;set;}

    public string Property2 {get;set;}

    public Bar Bar{get;set;}

    public List<Bar> Bars{get;set;}

}

​

public class Bar

{

    public string Prop1{get;set;}

    public string Prop2{get;set;}

}

​

    public static class ExpressionTreeHelper

    {

        /// <summary> Returns an IEnumerable of anonymous type defined by <paramref name="properties"/>. </summary>

        public static IEnumerable<dynamic> SelectDynamic<T>(this IEnumerable<T> source, params string[] properties)

        {

            return SelectProperties<T>(source.AsQueryable(), properties).Cast<dynamic>();

        }

        public static dynamic SelectDynamic(this object obj,params string[] propertyNames)

        {

             // get propertyinfo's from original type

            var properties = obj.GetType().GetProperties().Where(p => propertyNames.Contains(p.Name));

             // Create the x => expression

            var lambdaParameterExpression = Expression.Parameter(obj.GetType());

            // Create the x.<propertyName>'s

            var propertyExpressions = properties.Select(p => Expression.Property(lambdaParameterExpression, p));

            // Creating anonymous type using dictionary of property name and property type

            var anonymousType = AnonymousTypeUtils.CreateType(properties.ToDictionary(p => p.Name, p => p.PropertyType));

            var anonymousTypeConstructor = anonymousType.GetConstructors().Single();

            var anonymousTypeMembers = anonymousType.GetProperties().Cast<MemberInfo>().ToArray();

            // Create the new {} expression using 

            var anonymousTypeNewExpression = Expression.New(anonymousTypeConstructor, propertyExpressions, anonymousTypeMembers);

            var selectLambdaMethod = GetExpressionLambdaMethod(lambdaParameterExpression.Type, anonymousType);

            var selectBodyLambdaParameters = new object[] { anonymousTypeNewExpression, new[] { lambdaParameterExpression } };

            var selectBodyLambdaExpression = (LambdaExpression)selectLambdaMethod.Invoke(null, selectBodyLambdaParameters);

            return selectBodyLambdaExpression.Compile().DynamicInvoke(obj);

        }

​

        private static IQueryable SelectProperties<T>(this IQueryable<T> queryable, IEnumerable<string> propertyNames)

        {

            // get propertyinfo's from original type

            var properties = typeof(T).GetProperties().Where(p => propertyNames.Contains(p.Name));

​

            // Create the x => expression

            var lambdaParameterExpression = Expression.Parameter(typeof(T));

            // Create the x.<propertyName>'s

            var propertyExpressions = properties.Select(p => Expression.Property(lambdaParameterExpression, p));

​

            // Creating anonymous type using dictionary of property name and property type

            var anonymousType = AnonymousTypeUtils.CreateType(properties.ToDictionary(p => p.Name, p => p.PropertyType));

            var anonymousTypeConstructor = anonymousType.GetConstructors().Single();

            var anonymousTypeMembers = anonymousType.GetProperties().Cast<MemberInfo>().ToArray();

​

            // Create the new {} expression using 

            var anonymousTypeNewExpression = Expression.New(anonymousTypeConstructor, propertyExpressions, anonymousTypeMembers);

​

            var selectLambdaMethod = GetExpressionLambdaMethod(lambdaParameterExpression.Type, anonymousType);

            var selectBodyLambdaParameters = new object[] { anonymousTypeNewExpression, new[] { lambdaParameterExpression } };

            var selectBodyLambdaExpression = (LambdaExpression)selectLambdaMethod.Invoke(null, selectBodyLambdaParameters);

​

            var selectMethod = GetQueryableSelectMethod(typeof(T), anonymousType);

            var selectedQueryable = selectMethod.Invoke(null, new object[] { queryable, selectBodyLambdaExpression }) as IQueryable;

            return selectedQueryable;

        }

        private static MethodInfo GetExpressionLambdaMethod(Type entityType, Type funcReturnType)

        { 

            var prototypeLambdaMethod = GetStaticMethod(() => Expression.Lambda<Func<object, object>>(default(Expression), default(IEnumerable<ParameterExpression>))); 

            var lambdaGenericMethodDefinition = prototypeLambdaMethod.GetGenericMethodDefinition(); 

            var funcType = typeof(Func<,>).MakeGenericType(entityType, funcReturnType); 

            var lambdaMethod = lambdaGenericMethodDefinition.MakeGenericMethod(funcType); 

            return lambdaMethod; 

        } 

        private static MethodInfo GetQueryableSelectMethod(Type entityType, Type returnType)

        { 

            var prototypeSelectMethod = GetStaticMethod(() => Queryable.Select(default(IQueryable<object>), default(Expression<Func<object, object>>))); 

            var selectGenericMethodDefinition = prototypeSelectMethod.GetGenericMethodDefinition();

            return selectGenericMethodDefinition.MakeGenericMethod(entityType, returnType);

        } 

        private static MethodInfo GetStaticMethod(Expression<Action> expression)

        { 

            var lambda = expression as LambdaExpression; 

            var methodCallExpression = lambda.Body as MethodCallExpression; 

            return methodCallExpression.Method; 

        } 

    }