解析Expression >表達式

前言

　　時光荏苒，2020年不覺中已成過去。2021剛剛開頭，新的開始本應意氣風發、本應有會當凌絕頂豪情壯志，再不濟也該“鴻圖霸業談笑間”，且不管一入江湖是不是歲月摧的灑脫。很不幸，有些事情就是會突入其來，搞得你觸不及防，什么心情都沒有。但是我居然還是寫下了這篇博客。。。。。。嗯，總算是有地方表達以我糟糕心情了。

　　本來是想解決一下合並兩個Expression<Func<T, object>>類型的表達式的問題，比如：

　　Expression<Func<T, object>> exp1 = t => t.updateTime;　Expression<Func<T, object>> exp2 = t => new {t.age, t.name};

　　合並為一個表達式：Expression<Func<T, object>> exp1 = t => new {t.age, t.name， t.updateTime};

　　之前嘗試過一些辦法（比如下圖方法1和方法2，但是都失敗了）也請教過一些大佬，都沒有解決這個問題。於是我只能繞過這個問題用其他方法去實現了業務需求（在這里拋出這個問題，也希望能有人幫我解惑）

　　

退而求其次

　　我通過解析出來表達式中指定的屬性也能滿足我的需求，下面是我的實現方式：

        private static List<MemberInfo> SelectMembers(Expression properties)
        {
            if( properties.NodeType == ExpressionType.Convert)
            {
                List<MemberInfo> newArrMembers = new List<MemberInfo>
                {
                    ((MemberExpression)((UnaryExpression)properties).Operand).Member
                };
                return newArrMembers;
            }
            else
            {
                var newExp = (NewExpression)properties;
                if (newExp != null)
                {
                    return newExp.Members.ToList();
                }
                else
                {
                    var newArr = (NewArrayExpression)properties;
                    if (newArr != null)
                    {
                        List<MemberInfo> newArrMembers = new List<MemberInfo>();
                        foreach (var newArrExp in newArr.Expressions)
                            newArrMembers.AddRange(SelectMembers(newArrExp));
                        return newArrMembers.Distinct().ToList();
                    }
                    return null;
                }
            }
        }

 

如何使用

        public override Task<bool> UpdateAsync(T model, Expression<Func<T, object>> properties)
        {
            var mem = properties.SelectMembers();
            if (mem != null)
            {
                var sc = mem.Select(t => t.Name).ToArray();
                if (!sc.Contains("Updatedtime")) throw new Exception("表達必須指定updatedtime字段");
                if (sc.Contains("Createdtime")) throw new Exception("不允許更新的字段");
            }
            model.UpdatedTime = DateTime.Now;
            return base.UpdateAsync(model, properties);
        }

 

下面附上一些實用的擴展

using System;
using System.Collections.Generic;
using System.Dynamic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;

namespace Syspetro.Core.Extensions
{
    /// <summary>
    /// 合並表達式 And Or  Not擴展
    /// </summary>
    public static class ExpressionHelper
    {
        /// <summary>
        /// 合並表達式 expr1 AND expr2
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="expr1"></param>
        /// <param name="expr2"></param>
        /// <returns></returns>
        public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2)
        {
            if (expr1 == null)
                return expr2;
            else if (expr2 == null)
                return expr1;
            ParameterExpression newParameter = Expression.Parameter(typeof(T), "c");
            MyExpressionVisitor visitor = new MyExpressionVisitor(newParameter);
            var left = visitor.Visit(expr1.Body);
            var right = visitor.Visit(expr2.Body);

            return Expression.Lambda<Func<T, bool>>(Expression.And(left, right), newParameter);
        }
        /// <summary>
        /// 合並表達式 expr1 or expr2
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="expr1"></param>
        /// <param name="expr2"></param>
        /// <returns></returns>
        public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2)
        {
            if (expr1 == null)
                return expr2;
            else if (expr2 == null)
                return expr1;
            ParameterExpression newParameter = Expression.Parameter(typeof(T), "c");
            MyExpressionVisitor visitor = new MyExpressionVisitor(newParameter);

            var left = visitor.Visit(expr1.Body);
            var right = visitor.Visit(expr2.Body);
            var body = Expression.Or(left, right);
            return Expression.Lambda<Func<T, bool>>(body, newParameter);
        }
        /// <summary>
        /// 取反表達式
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="expr"></param>
        /// <returns></returns>
        public static Expression<Func<T, bool>> Not<T>(this Expression<Func<T, bool>> expr)
        {
            if (expr == null) return null;
            var candidateExpr = expr.Parameters[0];
            var body = Expression.Not(expr.Body);

            return Expression.Lambda<Func<T, bool>>(body, candidateExpr);
        }
        /// <summary>
        /// 獲取表達式屬性列表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="expr"></param>
        /// <returns></returns>
        public static List<MemberInfo> SelectMembers<T>(this Expression<Func<T, object>> expr)
        {
            return SelectMembers(expr.Body);
        }
        private static List<MemberInfo> SelectMembers(Expression properties)
        {
            if( properties.NodeType == ExpressionType.Convert)
            {
                List<MemberInfo> newArrMembers = new List<MemberInfo>
                {
                    ((MemberExpression)((UnaryExpression)properties).Operand).Member
                };
                return newArrMembers;
            }
            else
            {
                var newExp = (NewExpression)properties;
                if (newExp != null)
                {
                    return newExp.Members.ToList();
                }
                else
                {
                    var newArr = (NewArrayExpression)properties;
                    if (newArr != null)
                    {
                        List<MemberInfo> newArrMembers = new List<MemberInfo>();
                        foreach (var newArrExp in newArr.Expressions)
                            newArrMembers.AddRange(SelectMembers(newArrExp));
                        return newArrMembers.Distinct().ToList();
                    }
                    return null;
                }
            }
        }
    }
}

 

 

總結

　　縱然此時你的內心是千瘡百孔，萬般無奈，那又怎樣，你還想繼續生活嗎？那就只能繼續前向，繼續拼搏，努力讓自己更加強大。所以該做的事情還是要做，加油。