前一篇擴充套件了兩個常用驗證方法，本文將封裝兩個Lambda表示式操作，用來為下一篇的查詢擴充套件服務。

　　Lambda表示式是一種簡潔的匿名函式語法，可以用它將方法作為委託引數傳遞。在Linq中，大量使用Lambda表示式進行查詢，不過這種Lambda表示式被Expression包裝成表示式樹。表示式樹是直譯器的一個實現，它的作用是將一種語法轉換為另一種語法，比如將Lambda表示式解析為Sql語句。

　　使用Sql列名進行查詢的主要問題是，列名是一個字串，沒有智慧提示，如果輸入錯誤，也沒有編譯時檢查。使用Lambda表示式查詢可以解決這些問題，這是使用強型別的主要好處，另外當列名與屬性名不一致時，只需修改對映配置，業務程式碼不動，從而增強了系統的擴充套件性。

　　Lambda表示式的強型別在帶來諸多好處的同時，也產生了一些問題，比如t => t.Name==”a”這個表示式，如果想把值”a”拿出來進行操作，怎麼做到？值”a”對於查詢條件來講，是一個動態傳入的引數，如果對錶達式樹完全不瞭解，這也不是一件輕鬆的事。另外還有動態查詢的問題，這時候開始懷念弱型別的字串了，微軟提供了一個動態查詢的輔助類來解決這個問題，待用到的時候我再介紹。    

　　本文介紹的一個方法是GetValue，用來將Lambda謂詞表達式中的值取出來，另一個方法是GetCriteriaCount，用來判斷Lambda謂詞表達式中條件的個數。這兩個方法的具體應用將在下一篇介紹。

　　在Util專案中新增一個Lambda類，程式碼如下。

using System.Linq;
using System.Linq.Expressions;

namespace Util {
    /// <summary>
    /// Lambda表示式操作
    /// </summary>
    public class Lambda {

        #region GetValue(獲取值)

        /// <summary>
        /// 獲取值,範例：t => t.Name == "A",返回 A
        
 
/// </summary>
        /// <param name="expression">表示式,範例：t => t.Name == "A"</param>
        public static object GetValue( LambdaExpression expression ) {
            if ( expression == null )
                return null;
            BinaryExpression binaryExpression = GetBinaryExpression( expression );
            if ( binaryExpression != null )
                return GetBinaryValue( binaryExpression );
            var callExpression = expression.Body as MethodCallExpression;
            if ( callExpression != null )
                return GetMethodValue( callExpression );
            return null;
        }

        /// <summary>
        /// 獲取二元表示式
        /// </summary>
        private static BinaryExpression GetBinaryExpression( LambdaExpression expression ) {
            var binaryExpression = expression.Body as BinaryExpression;
            if ( binaryExpression != null )
                return binaryExpression;
            var unaryExpression = expression.Body as UnaryExpression;
            if ( unaryExpression == null )
                return null;
            return unaryExpression.Operand as BinaryExpression;
        }

        /// <summary>
        /// 獲取二元表示式的值
        /// </summary>
        private static object GetBinaryValue( BinaryExpression binaryExpression ) {
            var unaryExpression = binaryExpression.Right as UnaryExpression;
            if ( unaryExpression != null )
                return GetConstantValue( unaryExpression.Operand );
            return GetConstantValue( binaryExpression.Right );
        }

        /// <summary>
        /// 獲取常量值
        /// </summary>
        private static object GetConstantValue( Expression expression ) {
            var constantExpression = expression as ConstantExpression;
            if ( constantExpression == null )
                return null;
            return constantExpression.Value;
        }

        /// <summary>
        /// 獲取方法呼叫表示式的值
        /// </summary>
        private static object GetMethodValue( MethodCallExpression callExpression ) {
            var argumentExpression = callExpression.Arguments.FirstOrDefault();
            return GetConstantValue( argumentExpression );
        }

        #endregion

        #region GetCriteriaCount(獲取謂詞條件的個數)

        /// <summary>
        /// 獲取謂詞條件的個數
        /// </summary>
        /// <param name="expression">謂詞表達式,範例：t => t.Name == "A"</param>
        public static int GetCriteriaCount( LambdaExpression expression ) {
            if ( expression == null )
                return 0;
            var result = expression.ToString().Replace( "AndAlso", "|" ).Replace( "OrElse", "|" );
            return result.Split( '|' ).Count();
        }

        #endregion
    }
}

    為了進行測試，需要建立一個測試樣例類Test，程式碼如下。

namespace Util.Tests.Samples {
    /// <summary>
    /// 測試
    /// </summary>
    public class Test {
        public string Name { get; set; }
        public int Age { get; set; }
        public int? NullableInt { get; set; }
        public decimal? NullableDecimal { get; set; }
        public TestA A { get; set; }
        public class TestA {
            public int Integer { get; set; }
            public string Address { get; set; }
            public TestB B { get; set; }
            public class TestB {
                public string Name { get; set; }
            }
        }
    }
}

    單元測試程式碼如下。

using System;
using System.Linq.Expressions;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Util.Tests.Samples;

namespace Util.Tests {
    /// <summary>
    /// Lambda表示式操作測試
    /// </summary>
    [TestClass]
    public class LambdaTest {

        #region GetValue(獲取成員值)

        /// <summary>
        /// 獲取成員值,委託返回型別為Object
        /// </summary>
        [TestMethod]
        public void TestGetValue_Object() {
            Expression<Func<Test, object>> expression = test => test.Name == "A";
            Assert.AreEqual( "A", Lambda.GetValue( expression ) );
        }

        /// <summary>
        /// 獲取成員值,委託返回型別為bool
        /// </summary>
        [TestMethod]
        public void TestGetValue_Boolean() {
            //空值返回null
            Assert.AreEqual( null, Lambda.GetValue( null ) );

            //一級返回值
            Expression<Func<Test, bool>> expression = test => test.Name == "A";
            Assert.AreEqual( "A", Lambda.GetValue( expression ) );

            //二級返回值
            Expression<Func<Test, bool>> expression2 = test => test.A.Integer == 1;
            Assert.AreEqual( 1, Lambda.GetValue( expression2 ) );

            //三級返回值
            Expression<Func<Test, bool>> expression3 = test => test.A.B.Name == "B";
            Assert.AreEqual( "B", Lambda.GetValue( expression3 ) );
        }

        /// <summary>
        /// 獲取可空型別的值
        /// </summary>
        [TestMethod]
        public void TestGetValue_Nullable() {
            //可空整型
            Expression<Func<Test, bool>> expression = test => test.NullableInt == 1;
            Assert.AreEqual( 1, Lambda.GetValue( expression ) );

            //可空decimal
            expression = test => test.NullableDecimal == 1.5M;
            Assert.AreEqual( 1.5M, Lambda.GetValue( expression ) );
        }

        /// <summary>
        /// 獲取成員值，運算子為方法
        /// </summary>
        [TestMethod]
        public void TestGetValue_Method() {
            //1級返回值
            Expression<Func<Test, bool>> expression = t => t.Name.Contains( "A" );
            Assert.AreEqual( "A", Lambda.GetValue( expression ) );

            //二級返回值
            expression = t => t.A.Address.Contains( "B" );
            Assert.AreEqual( "B", Lambda.GetValue( expression ) );

            //三級返回值
            expression = t => t.A.B.Name.StartsWith( "C" );
            Assert.AreEqual( "C", Lambda.GetValue( expression ) );
        }

        #endregion

        #region GetCriteriaCount(獲取謂詞條件的個數)

        /// <summary>
        /// 獲取謂詞條件的個數
        /// </summary>
        [TestMethod]
        public void TestGetCriteriaCount() {
            //0個條件
            Assert.AreEqual( 0, Lambda.GetCriteriaCount( null ) );

            //1個條件
            Expression<Func<Test, bool>> expression = test => test.Name == "A";
            Assert.AreEqual( 1, Lambda.GetCriteriaCount( expression ) );

            //2個條件，與連線符
            expression = test => test.Name == "A" && test.Name == "B";
            Assert.AreEqual( 2, Lambda.GetCriteriaCount( expression ) );

            //2個條件，或連線符
            expression = test => test.Name == "A" || test.Name == "B";
            Assert.AreEqual( 2, Lambda.GetCriteriaCount( expression ) );

            //3個條件
            expression = test => test.Name == "A" && test.Name == "B" || test.Name == "C";
            Assert.AreEqual( 3, Lambda.GetCriteriaCount( expression ) );

            //3個條件,包括導航屬性
            expression = test => test.A.Address == "A" && test.Name == "B" || test.Name == "C";
            Assert.AreEqual( 3, Lambda.GetCriteriaCount( expression ) );
        }

        /// <summary>
        /// 獲取謂詞條件的個數，運算子為方法
        /// </summary>
        [TestMethod]
        public void TestGetCriteriaCount_Method() {
            //1個條件
            Expression<Func<Test, bool>> expression = t => t.Name.Contains( "A" );
            Assert.AreEqual( 1, Lambda.GetCriteriaCount( expression ) );

            //2個條件,與連線
            expression = t => t.Name.Contains( "A" ) && t.Name == "A";
            Assert.AreEqual( 2, Lambda.GetCriteriaCount( expression ) );

            //2個條件,或連線,包含導航屬性
            expression = t => t.Name.Contains( "A" ) || t.A.Address == "A";
            Assert.AreEqual( 2, Lambda.GetCriteriaCount( expression ) );
        }

        #endregion
    }
}

需要注意的是，GetValue方法不僅要能獲取t=>t.Name==”a”這樣的二元表示式，還要能獲取方法呼叫表示式中的值，比如t=>t.Name.Contains(“a”)。

　　下面再增加一個擴充套件方法，在Util專案中新增名為Extensions.Expression的檔案，程式碼如下。

using System;
using System.Linq.Expressions;

namespace Util {
    /// <summary>
    /// 表示式擴充套件
    /// </summary>
    public static partial class Extensions {

        #region Value(獲取lambda表示式的值)

        /// <summary>
        /// 獲取lambda表示式的值
        /// </summary>
        /// <typeparam name="T">物件型別</typeparam>
        public static object Value<T>( this Expression<Func<T, bool>> expression ) {
            return Lambda.GetValue( expression );
        }

        #endregion
    }
}

 　　Lambda表示式不僅在查詢上大展身手，而且在表現層，比如Mvc上也有大量的應用。本文只介紹下一篇基礎查詢擴充套件需要用到的兩個方法，其它方法我會在需要用到的時候補充進來。

　　.Net應用程式框架交流QQ群: 386092459，歡迎有興趣的朋友加入討論。