一、前言

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

看到這個標題就有一種疑問，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的講解了。其實沒寫一篇博文，蝸牛都會去羅列和梳理相關知識點，這也讓蝸牛獲益匪淺，也希望蝸牛的部落格能幫助到園友，這就是所謂的“贈人玫瑰，手留餘香”