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

1、前言

原本計算這篇文章在後面須要運用的時候寫的，可是既然寫到表達式的擴展呢，就一塊兒寫完吧。

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

表達式系列目錄

C# 表達式樹講解（一）

C# 表達式樹遍歷（二）

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

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

2、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; }
}

View Code

添加數據

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
});

View Code

好了如今咱們就查詢數據

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表達式的時候，就須要將參數合併成一個。

通過這樣的擴展，咱們就能夠根據咱們的實際狀況，拼湊好須要的表達式，獲得咱們想要的結果。

3、總結

表達式樹方面的講解，終於能夠告一段落了。一直後沒有這樣的寫文章，如今以爲寫文章仍是真的挺累的，今年中秋節的這三天，算是所有的給博客園了。不過這三天講解的內容，基本上把後面Dapper的擴展須要用的技術都鋪墊了，後面咱們就繼續對ORM的講解了。其實沒寫一篇博文，蝸牛都會去羅列和梳理相關知識點，這也讓蝸牛獲益匪淺，也但願蝸牛的博客能幫助到園友，這就是所謂的「贈人玫瑰，手留餘香」吧。