Expression "func" tSource, object "to expression" func "tSource, object" []

 // Handle multiple attribute generation Expression expression , from Expression<Func<TSource, object>>  To Expression<Func<TSource, object>>[], Single to multiple 
// from  x=>new{x.a,x.b}   To  x=>x.a x=>x.b

private static Expression<Func<TSource, object>>[] ProcessExpressionObjet<TSource>(Expression<Func<TSource, object>> propertyExpression)
        {
            Expression<Func<TSource, object>>[] expressions = new Expression<Func<TSource, object>>[] { };
            Expression expression = propertyExpression.Body;
            while (expression.NodeType == ExpressionType.Convert || expression.NodeType == ExpressionType.ConvertChecked)
                expression = ((UnaryExpression)expression).Operand;
            //Parameter
            ParameterExpression parameterExpression = propertyExpression.Parameters.Single<ParameterExpression>();

            if (expression is NewExpression)
            {
                NewExpression newExpression = expression as NewExpression;
                if (newExpression == null)
                    return expressions;
                expressions = new Expression<Func<TSource, object>>[newExpression.Arguments.Count];
                int index = 0;
                foreach (Expression subExpression in newExpression.Arguments)
                {
                    MemberExpression member = subExpression as MemberExpression;
                    Expression exProperty = Expression.Property(parameterExpression, member.Member.Name);
                    var body = Expression.Convert(exProperty, typeof(object));
                    expressions[index] = Expression.Lambda<Func<TSource, object>>(body, parameterExpression);
                    index++;
                }
                return expressions;
            }
            else if (expression is MemberExpression)
            {
                expressions = new Expression<Func<TSource, object>>[1];
                Expression exProperty = Expression.Property(parameterExpression, (expression as MemberExpression).Member.Name);
                var body = Expression.Convert(exProperty, typeof(object));
                expressions[0] = Expression.Lambda<Func<TSource, object>>(body, parameterExpression);
                return expressions;
            }
            else
                return expressions;
        }

Source idea ：

Get entities T Of all properties of lambda Expression array ： Such as x->x.a,x->x.b,x->x.b,x->x.c

public static Expression<Func<T, object>>[] GetExpressions<T>()
        {
            var properties = typeof(T).GetProperties();
            Expression<Func<T, object>>[] expressions = new Expression<Func<T, object>>[properties.Length];
            var p = Expression.Parameter(typeof(T), "x");
            for (int i = 0; i < properties.Length; i++)
            {
                Expression exProperty = Expression.Property(p, properties[i]);
                var body = Expression.Convert(exProperty, typeof(object));

                expressions[i] = Expression.Lambda<Func<T, object>>(body, p);
            }
            return expressions;
        }