目錄

• 解決方案：
• 完美解決

事情的起因是公司一個(gè)小伙子問(wèn)了我個(gè)問(wèn)題 “海哥，來(lái)幫我看下這段代碼怎么不行”

Func<Report,bool> nameFilter = x=>x.Name == "test";
DbContext.Report.Where(x=>x.State==1 && nameFilter(x));

我一看，好家伙，這么騷的代碼都能讓你想出來(lái)，正常情況下用Linq To Object是可以這么操作的，但是EF的IQueryable查詢是不能這么操作的。
Linq To Object是直接執(zhí)行表達(dá)式，他就是個(gè)委托方法，里面嵌套多少層委托和方法都是能直接執(zhí)行的
IQueryable并不會(huì)執(zhí)行表達(dá)式和方法，是把表達(dá)式轉(zhuǎn)換為對(duì)應(yīng)的Sql語(yǔ)句來(lái)執(zhí)行，解析到nameFilter的時(shí)候他就懵逼了，這是啥玩意兒啊，sql里面沒(méi)有這種東西啊，他就轉(zhuǎn)換不了了。

小伙子知道后明細(xì)很失望，那不能啊，也不是我想顯擺我的技術(shù)，就是想讓小伙子能繼續(xù)他的騷操作，給他來(lái)點(diǎn)海克斯科技與狠活。

解決方案：

//表達(dá)式
Func<Report,bool> nameFilter = x=>x.Name == "test";
Func<Report,bool> stateFilter = x=>x.State==1;
//合并為
Func<Report,bool> whereFilter = x=>x.Name == "test" && x.State==1;

//調(diào)用
DbContext.Report.Where(whereFilter);

完美解決

那怎么合并，當(dāng)然得自己構(gòu)造一個(gè)新的表達(dá)式，構(gòu)造表達(dá)式需要用到Expression類，如果沒(méi)有用過(guò)這個(gè)類，可以按照下面的方式來(lái)調(diào)試看看一個(gè)表達(dá)式轉(zhuǎn)換為表達(dá)式樹是怎么樣的。

TestExpression(x=>x.Name == "test",x=>x.State==1);

public static void TestExpression(Expression<Func<Report, bool>> left,Expression<Func<Report, bool>> right)
{ 
    //調(diào)試查看expression對(duì)象
    var bodyLeft = left.Body;//這個(gè)就是x.Name == "test"
    var bodyRight = right.Body;//這個(gè)就是x.State==1
}

好，這里我們能獲取到表達(dá)式的Body，然后使用Expression類能很好的合并兩個(gè)表達(dá)式的body

var andAlso = Expression.AndAlso(bodyLeft ,bodyRight);//x.Name == "test" && x.State==1

這樣還不行，這兩個(gè)表達(dá)式是兩個(gè)不同的委托對(duì)象，他們的參數(shù)x也是兩個(gè)不同的對(duì)象，合并了又沒(méi)完全合并

這就需要用到ExpressionVisitor類來(lái)遞歸表達(dá)式樹，把兩個(gè)表達(dá)式的參數(shù)替換為同一個(gè)參數(shù)。

    /// <summary>
    /// 替換表達(dá)式參數(shù)
    /// </summary>
    public class ReplaceExpressionVisitor : ExpressionVisitor
    {
private Expression _leftParameter;

public ReplaceExpressionVisitor(Expression leftParameter)
{
    _leftParameter= leftParameter;
}

protected override Expression VisitParameter(ParameterExpression node)
{
    return _leftParameter;
}
    }

最終

TestExpression(x=>x.Name == "test",x=>x.State==1);

public static void TestExpression(Expression<Func<Report, bool>> left,Expression<Func<Report, bool>> right)
{ 
    //調(diào)試查看expression對(duì)象
    var bodyLeft = left.Body;//這個(gè)就是x.Name == "test"
    var bodyRight = right.Body;//這個(gè)就是x.State==1
    var leftParameter = left.Parameters[0];
    //表達(dá)式遞歸訪問(wèn)
    var visitor =new ReplaceExpressionVisitor(leftParameter);
    //替換參數(shù)
    bodyRight = visitor.Visit(bodyRight);
    //合并表達(dá)式
    var expression = Expression.AndAlso(bodyLeft , bodyRight);
    //構(gòu)建表達(dá)式
    var whereExpression= Expression.Lambda<Func<Report, bool>>(expression , left.Parameters);
    //編譯表達(dá)式
    var whereFilter = whereExpression.Compile();
    //使用
    DbContext.Report.Where(whereFilter);
}

正想給小老弟顯擺一下的時(shí)候，他又去寫其他騷代碼了

騷不過(guò)騷不過(guò)，完善一下列子，下面是完整的代碼

小嫩手不想動(dòng)的小伙伴可以直接nuget上查找DynamicExpression.Core,直接使用

更多源碼看本人github

    /// <summary>
    /// 替換表達(dá)式參數(shù)
    /// </summary>
    public class ReplaceExpressionVisitor : ExpressionVisitor
    {
private Dictionary<Expression, Expression> _parameters;

public ReplaceExpressionVisitor(Dictionary<Expression,Expression> parameters)
{
    _parameters = parameters;
}

protected override Expression VisitParameter(ParameterExpression node)
{
    if (_parameters.TryGetValue(node, out Expression _newValue))
    {
return _newValue;
    }
    return base.Visit(node);
}
    }

    /// <summary>
    /// 表達(dá)式擴(kuò)展
    /// </summary>
    public static class ExpressionExtension
    {

/// <summary>
/// 使用AndAlso合并表達(dá)式
/// </summary>
/// <param name="exprs"></param>
/// <returns></returns>
public static Expression<T> AndAlso<T>(this IList<Expression<T>> exprs)
{
    if (exprs.Count == 0) return null;
    if (exprs.Count == 1) return exprs[0];

    var leftExpr = exprs[0];
    var left = leftExpr.Body;
    for (int i = 1; i < exprs.Count; i++)
    {
var expr = exprs[i];
var visitor = GetReplaceExpressionVisitor(expr.Parameters, leftExpr.Parameters);
var right = visitor.Visit(expr.Body);
left = Expression.AndAlso(left, right);
    }
    return Expression.Lambda<T>(left, leftExpr.Parameters);
}

/// <summary>
/// 使用AndAlso合并表達(dá)式
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="left"></param>
/// <param name="right"></param>
/// <returns>left AndAlso right</returns>
public static Expression<T> AndAlso<T>(this Expression<T> left, Expression<T> right)
{
    return AndAlso(new List<Expression<T>>() { left, right });
}

/// <summary>
/// 使用OrElse合并表達(dá)式
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="exprs"></param>
/// <returns></returns>
public static Expression<T> OrElse<T>(this IList<Expression<T>> exprs)
{
    if (exprs.Count == 0) return null;
    if (exprs.Count == 1) return exprs[0];

    var leftExpr = exprs[0];
    var left = leftExpr.Body;
    for (int i = 1; i < exprs.Count; i++)
    {
var expr = exprs[i];
var visitor = GetReplaceExpressionVisitor(expr.Parameters, leftExpr.Parameters);
var right = visitor.Visit(expr.Body);
left = Expression.OrElse(left, right);
    }
    return Expression.Lambda<T>(left, leftExpr.Parameters);
}

/// <summary>
/// 使用OrElse合并表達(dá)式
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="left"></param>
/// <param name="right"></param>
/// <returns>left OrElse right</returns>
public static Expression<T> OrElse<T>(this Expression<T> left, Expression<T> right)
{
    return OrElse(new List<Expression<T>>() { left, right });
}
/// <summary>
/// 構(gòu)建visitor
/// </summary>
/// <param name="oldParameters"></param>
/// <param name="newParameters"></param>
/// <returns></returns>
private static ReplaceExpressionVisitor GetReplaceExpressionVisitor(ReadOnlyCollection<ParameterExpression> oldParameters, ReadOnlyCollection<ParameterExpression> newParameters)
{
    Dictionary<Expression, Expression> dic = new Dictionary<Expression, Expression>();
    for (int i = 0; i < oldParameters.Count; i++)
    {
dic.Add(oldParameters[i],newParameters[i]);
    }
    return new ReplaceExpressionVisitor(dic);
}
    }

使用

string connectString = "Data Source=.;Initial Catalog=RportTest;Integrated Security=True";
var optionsBuilder = new DbContextOptionsBuilder<TestContext>();
optionsBuilder.UseSqlServer(connectString);
using (TestContext ctx = new TestContext(optionsBuilder.Options))
{

    Expression<Func<ReportData, bool>> epxr1 = report => report.ID == 2023;
    Expression<Func<ReportData, bool>> epxr2 = report => report.Name == "test1";

    var epxr3 = new List<Expression<Func<ReportData, bool>>>() { epxr1, epxr2 };

    var andPredicate = epxr3.AndAlso();
    var andQuery = ctx.ReportData.Where(andPredicate);
    string andSql = andQuery.ToQueryString();
    var andResult = andQuery.ToList();

    var orPredicate = epxr3.OrElse();
    var orQuery = ctx.ReportData.Where(orPredicate);
    string orSql = orQuery.ToQueryString();
    var orResult = orQuery.ToList();
}

到此這篇關(guān)于.net lambda表達(dá)式合并的文章就介紹到這了,更多相關(guān).net lambda表達(dá)式內(nèi)容請(qǐng)搜索以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持！