C# 表達式樹Lambda擴展（四）

一、前言

本來計算這篇文章在后面需要運用的時候寫的，但是既然寫到表達式的擴展呢，就一起寫完吧。

看到這個標題就有一種疑問，Lambda表達式本來就是表達式樹，還需要怎么擴展？那就看看下面的內容，你就知道了。

表達式系列目錄

C# 表達式樹講解（一）

C# 表達式樹遍歷（二）

C# 表達式樹分頁擴展（三）

C# 表達式樹Lambda擴展（四）

二、Lambda擴展

這里先不忙解答上面的問題，我們先看下這樣一個應用場景。

一個頁面的請求，里面帶有一些條件查詢，請求類如下

public class ScoreRequest
{
    public string CourseName { get; set; }
    public string StudentName { get; set; }
}

要求查詢與課程名稱和學生名稱匹配的數據

數據源我們就以上一例子的數據源

數據源類

public class ScoreClass
{
    public string CourseName { get; set; }
    public string StudentName { get; set; }
    public decimal Score { get; set; }
}

添加數據

var datas = new List<ScoreClass>();
datas.Add(new ScoreClass
{
    CourseName = "數學",
    StudentName = "學生A",
    Score = 60
});
datas.Add(new ScoreClass
{
    CourseName = "數學",
    StudentName = "學生B",
    Score = 65
});
datas.Add(new ScoreClass
{
    CourseName = "數學",
    StudentName = "學生C",
    Score = 70
});
datas.Add(new ScoreClass
{
    CourseName = "數學",
    StudentName = "學生D",
    Score = 75
});
datas.Add(new ScoreClass
{
    CourseName = "數學",
    StudentName = "學生E",
    Score = 80
});
datas.Add(new ScoreClass
{
    CourseName = "數學",
    StudentName = "學生F",
    Score = 81
});
datas.Add(new ScoreClass
{
    CourseName = "數學",
    StudentName = "學生G",
    Score = 82
});
datas.Add(new ScoreClass
{
    CourseName = "數學",
    StudentName = "學生H",
    Score = 83
});
datas.Add(new ScoreClass
{
    CourseName = "數學",
    StudentName = "學生I",
    Score = 84
});

好了現在我們就查詢數據

var request = new ScoreRequest()
            {
                CourseName = "數",
                StudentName = "H"
            };
            var resultDatas = datas.Where(e => e.CourseName.Contains(request.CourseName) && e.StudentName.Contains(request.StudentName))
                .ToList();

如果查詢對象里面CourseName和StudentName字段都有值得話，這樣寫沒問題。如果沒值，那就最后的數據，就不准確了。

如果是直接拼湊sql語句，我們可以用if(String.IsNullOrEmpty())來判斷，但是現在判斷了，怎么拼湊Lambda表達式呢？

所以就需要我們對Lambda表達式進行擴展，讓他支持這種情況。那上面的問題，就不用再專門回答了吧！！！！

創建一個LambdaExtension的類，代碼如下

public static class LambdaExtension
{
    public static Expression<Func<T, bool>> True<T>() { return param => true; }
    public static Expression<Func<T, bool>> False<T>() { return param => false; }
    public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
    {
        return first.Compose(second, Expression.AndAlso);
    }
    public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
    {
        return first.Compose(second, Expression.OrElse);
    }
    private static Expression<T> Compose<T>(this Expression<T> first, Expression<T> second, Func<Expression, Expression, Expression> merge)
    {
        var map = first.Parameters
            .Select((f, i) => new { f, s = second.Parameters[i] })
            .ToDictionary(p => p.s, p => p.f);
        var secondBody = PFTParameterExtension.ReplaceParameters(map, second.Body);
        return Expression.Lambda<T>(merge(first.Body, secondBody), first.Parameters);
    }

    private class PFTParameterExtension : ExpressionVisitor
    {
        private readonly Dictionary<ParameterExpression, ParameterExpression> map;

        public PFTParameterExtension()
        {

        }

        public PFTParameterExtension(Dictionary<ParameterExpression, ParameterExpression> map)
        {
            this.map = map ?? new Dictionary<ParameterExpression, ParameterExpression>();
        }

        /// <summary>
        /// 替換參數
        /// </summary>
        /// <param name="map">The map.</param>
        /// <param name="exp">The exp.</param>
        /// <returns>Expression</returns>
        public static Expression ReplaceParameters(Dictionary<ParameterExpression, ParameterExpression> map, Expression exp)
        {
            return new PFTParameterExtension(map).Visit(exp);
        }

        protected override Expression VisitParameter(ParameterExpression p)
        {
            ParameterExpression replacement;
            if (map != null && map.Count > 0 && map.TryGetValue(p, out replacement))
            {
                p = replacement;
            }
            return base.VisitParameter(p);
        }

    }

}

這里面私有化了一個表達式樹訪問器，他的作用主要是用來同步Lambda表達式里面的參數。

下面是調用方式

            var expression = LambdaExtension.True<ScoreClass>();
            if (!string.IsNullOrWhiteSpace(request.CourseName))
                expression = expression.And(e => e.CourseName.Contains(request.CourseName));
            if (!string.IsNullOrWhiteSpace(request.StudentName))
                expression = expression.And(et => et.StudentName.Contains(request.StudentName));

            var resultDatas = datas.Where(expression.Compile())
                .ToList();
            Console.WriteLine($"查詢結果：\n{string.Join("\n", resultDatas.Select(e => $"{e.StudentName} {e.CourseName} {e.Score}"))}");

where條件里面只能帶委托，而我們的expression是Lambda表達式，所以需要Compile進行委托編譯。

運行結果：

仔細看代碼，第一個條件And里面的參數是“e”，第二個條件里面的參數是et，同一個Lambda表達式里面（這里只有一個參數），參數肯定是一致的，所以在LambdaExtension類中，在合並兩個Lambda表達式的時候，就需要將參數合並成一個。

經過這樣的擴展，我們就可以根據我們的實際情況，拼湊好需要的表達式，得到我們想要的結果。

三、總結

表達式樹方面的講解，終於可以告一段落了。一直后沒有這樣的寫文章，現在覺得寫文章還是真的挺累的，今年中秋節的這三天，算是全部的給博客園了。不過這三天講解的內容，基本上把后面Dapper的擴展需要用的技術都鋪墊了，后面我們就繼續對ORM的講解了。其實沒寫一篇博文，蝸牛都會去羅列和梳理相關知識點，這也讓蝸牛獲益匪淺，也希望蝸牛的博客能幫助到園友，這就是所謂的“贈人玫瑰，手留余香”吧。