Util應用程序框架公共操做類(八):Lambda表達式公共操做類(二)
前面介紹了查詢的基礎擴展，下面準備給你們介紹一些有用的查詢封裝手法，好比對日期範圍查詢，數值範圍查詢的封裝等，爲了支持這些功能，須要加強公共操做類。express
Lambda表達式公共操做類，我在前面已經簡單介紹過，要麼從Lambda表達式中獲取信息，要麼動態建立Lambda表達式，本篇直接貼代碼，若是發現有些代碼與之前不一樣，緣由有二，一是以前還未用到，只發了部分代碼，二是可能代碼已重構。須要說明的一點是，我不會考慮代碼兼容性，API命名隨時可能修改，若是你直接將本系列的代碼用到你的項目上要格外注意。框架
修改Util項目的Lambda類，代碼以下。單元測試
using System; using System.Collections.Generic; using System.Linq; using System.Linq.Expressions; using System.Reflection; using DynamicExpression = Util.Lambdas.Dynamics.DynamicExpression; namespace Util { /// <summary>
/// Lambda表達式操做 /// </summary>
public class Lambda { #region GetName(獲取成員名稱)
/// <summary>
/// 獲取成員名稱，範例：t => t.Name,返回 Name /// </summary>
/// <param name="expression">表達式,範例：t => t.Name</param>
public static string GetName( LambdaExpression expression ) { var memberExpression = GetMemberExpression( expression ); if ( memberExpression == null ) return string.Empty; string result = memberExpression.ToString(); return result.Substring( result.IndexOf( ".", StringComparison.Ordinal ) + 1 ); } /// <summary>
/// 獲取成員表達式 /// </summary>
private static MemberExpression GetMemberExpression( LambdaExpression expression ) { if ( expression == null ) return null; var unaryExpression = expression.Body as UnaryExpression; if ( unaryExpression == null ) return expression.Body as MemberExpression; return unaryExpression.Operand as MemberExpression; } #endregion
#region GetMember(獲取成員)
/// <summary>
/// 獲取成員 /// </summary>
/// <param name="expression">表達式,範例：t => t.Name</param>
public static MemberInfo GetMember( LambdaExpression expression ) { var memberExpression = GetMemberExpression( expression ); if ( memberExpression == null ) return null; return memberExpression.Member; } #endregion
#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; var memberExpression = expression.Body as MemberExpression; if ( memberExpression != null ) return GetMemberValue( memberExpression ); 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 ); var memberExpression = binaryExpression.Right as MemberExpression; if ( memberExpression != null ) return GetMemberValue( memberExpression ); return GetConstantValue( binaryExpression.Right ); } /// <summary>
/// 獲取屬性表達式的值 /// </summary>
private static object GetMemberValue( MemberExpression expression ) { if ( expression == null ) return null; var field = expression.Member as FieldInfo; if ( field != null ) { var constValue = GetConstantValue( expression.Expression ); return field.GetValue( constValue ); } var property = expression.Member as PropertyInfo; if ( property == null ) return null; var value = GetMemberValue( expression.Expression as MemberExpression ); return property.GetValue( value ); } /// <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(); var memberExpression = argumentExpression as MemberExpression; if ( memberExpression != null ) return GetMemberValue( memberExpression ); return GetConstantValue( argumentExpression ); } #endregion
#region GetParameter(獲取參數)
/// <summary>
/// 獲取參數，範例：t.Name,返回 t /// </summary>
/// <param name="expression">表達式，範例：t.Name</param>
public static ParameterExpression GetParameter( LambdaExpression expression ) { if ( expression == null ) return null; BinaryExpression binaryExpression = GetBinaryExpression( expression ); if ( binaryExpression == null ) return null; return GetParameterByMember( binaryExpression.Left ); } /// <summary>
/// 遞歸獲取參數 /// </summary>
private static ParameterExpression GetParameterByMember( Expression expression ) { if ( expression == null ) return null; ParameterExpression result = expression as ParameterExpression; if ( result != null ) return result; MemberExpression memberExpression = expression as MemberExpression; if ( memberExpression == null ) return null; return GetParameterByMember( memberExpression.Expression ); } #endregion
#region GetAttribute(獲取特性)
/// <summary>
/// 獲取特性 /// </summary>
/// <typeparam name="TEntity">實體類型</typeparam>
/// <typeparam name="TProperty">屬性類型</typeparam>
/// <typeparam name="TAttribute">特性類型</typeparam>
/// <param name="propertyExpression">屬性表達式</param>
public static TAttribute GetAttribute<TEntity, TProperty, TAttribute>( Expression<Func<TEntity, TProperty>> propertyExpression ) where TAttribute : Attribute { var memberInfo = GetMember( propertyExpression ); return memberInfo.GetCustomAttribute<TAttribute>(); } #endregion
#region GetAttributes(獲取特性列表)
/// <summary>
/// 獲取特性列表 /// </summary>
/// <typeparam name="TEntity">實體類型</typeparam>
/// <typeparam name="TProperty">屬性類型</typeparam>
/// <typeparam name="TAttribute">特性類型</typeparam>
/// <param name="propertyExpression">屬性表達式</param>
public static IEnumerable<TAttribute> GetAttributes<TEntity, TProperty, TAttribute>( Expression<Func<TEntity, TProperty>> propertyExpression ) where TAttribute : Attribute { var memberInfo = GetMember( propertyExpression ); return memberInfo.GetCustomAttributes<TAttribute>(); } #endregion
#region Constant(獲取常量)
/// <summary>
/// 獲取常量表達式，自動轉換值的類型 /// </summary>
/// <param name="expression">表達式</param>
/// <param name="value">值</param>
public static ConstantExpression Constant( Expression expression, object value ) { var memberExpression = expression as MemberExpression; if ( memberExpression == null ) return Expression.Constant( value ); return Expression.Constant( value, memberExpression.Type ); } #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
#region Equal(等於表達式)
/// <summary>
/// 建立等於運算lambda表達式 /// </summary>
/// <typeparam name="T">對象類型</typeparam>
/// <param name="propertyName">屬性名</param>
/// <param name="value">值</param>
public static Expression<Func<T, bool>> Equal<T>( string propertyName, object value ) { var parameter = CreateParameter<T>(); return parameter.Property( propertyName ) .Equal( value ) .ToLambda<Func<T, bool>>( parameter ); } /// <summary>
/// 建立參數 /// </summary>
private static ParameterExpression CreateParameter<T>() { return Expression.Parameter( typeof( T ), "t" ); } #endregion
#region NotEqual(不等於表達式)
/// <summary>
/// 建立不等於運算lambda表達式 /// </summary>
/// <typeparam name="T">對象類型</typeparam>
/// <param name="propertyName">屬性名</param>
/// <param name="value">值</param>
public static Expression<Func<T, bool>> NotEqual<T>( string propertyName, object value ) { var parameter = CreateParameter<T>(); return parameter.Property( propertyName ) .NotEqual( value ) .ToLambda<Func<T, bool>>( parameter ); } #endregion
#region Greater(大於表達式)
/// <summary>
/// 建立大於運算lambda表達式 /// </summary>
/// <typeparam name="T">對象類型</typeparam>
/// <param name="propertyName">屬性名</param>
/// <param name="value">值</param>
public static Expression<Func<T, bool>> Greater<T>( string propertyName, object value ) { var parameter = CreateParameter<T>(); return parameter.Property( propertyName ) .Greater( value ) .ToLambda<Func<T, bool>>( parameter ); } #endregion
#region Less(小於表達式)
/// <summary>
/// 建立小於運算lambda表達式 /// </summary>
/// <typeparam name="T">對象類型</typeparam>
/// <param name="propertyName">屬性名</param>
/// <param name="value">值</param>
public static Expression<Func<T, bool>> Less<T>( string propertyName, object value ) { var parameter = CreateParameter<T>(); return parameter.Property( propertyName ) .Less( value ) .ToLambda<Func<T, bool>>( parameter ); } #endregion
#region GreaterEqual(大於等於表達式)
/// <summary>
/// 建立大於等於運算lambda表達式 /// </summary>
/// <typeparam name="T">對象類型</typeparam>
/// <param name="propertyName">屬性名</param>
/// <param name="value">值</param>
public static Expression<Func<T, bool>> GreaterEqual<T>( string propertyName, object value ) { var parameter = CreateParameter<T>(); return parameter.Property( propertyName ) .GreaterEqual( value ) .ToLambda<Func<T, bool>>( parameter ); } #endregion
#region LessEqual(小於等於表達式)
/// <summary>
/// 建立小於等於運算lambda表達式 /// </summary>
/// <typeparam name="T">對象類型</typeparam>
/// <param name="propertyName">屬性名</param>
/// <param name="value">值</param>
public static Expression<Func<T, bool>> LessEqual<T>( string propertyName, object value ) { var parameter = CreateParameter<T>(); return parameter.Property( propertyName ) .LessEqual( value ) .ToLambda<Func<T, bool>>( parameter ); } #endregion
#region Contains(調用Contains方法)
/// <summary>
/// 調用Contains方法 /// </summary>
/// <typeparam name="T">對象類型</typeparam>
/// <param name="propertyName">屬性名</param>
/// <param name="value">值</param>
public static Expression<Func<T, bool>> Contains<T>( string propertyName, object value ) { return Call<T>( propertyName, "Contains", value ); } /// <summary>
/// 調用方法 /// </summary>
private static Expression<Func<T, bool>> Call<T>( string propertyName, string methodName, object value ) { var parameter = CreateParameter<T>(); return parameter.Property( propertyName ) .Call( methodName, value ) .ToLambda<Func<T, bool>>( parameter ); } #endregion
#region Starts(調用StartsWith方法)
/// <summary>
/// 調用StartsWith方法 /// </summary>
/// <typeparam name="T">對象類型</typeparam>
/// <param name="propertyName">屬性名</param>
/// <param name="value">值</param>
public static Expression<Func<T, bool>> Starts<T>( string propertyName, string value ) { var parameter = CreateParameter<T>(); var property = parameter.Property( propertyName ); var call = Expression.Call( property, property.Type.GetMethod( "StartsWith", new Type[] { typeof( string ) } ), Expression.Constant( value ) ); return call.ToLambda<Func<T, bool>>( parameter ); } #endregion
#region Ends(調用EndsWith方法)
/// <summary>
/// 調用EndsWith方法 /// </summary>
/// <typeparam name="T">對象類型</typeparam>
/// <param name="propertyName">屬性名</param>
/// <param name="value">值</param>
public static Expression<Func<T, bool>> Ends<T>( string propertyName, string value ) { var parameter = CreateParameter<T>(); var property = parameter.Property( propertyName ); var call = Expression.Call( property, property.Type.GetMethod( "EndsWith", new Type[] { typeof( string ) } ), Expression.Constant( value ) ); return call.ToLambda<Func<T, bool>>( parameter ); } #endregion
#region ParsePredicate(解析爲謂詞表達式)
/// <summary>
/// 解析爲謂詞表達式 /// </summary>
/// <typeparam name="T">實體類型</typeparam>
/// <param name="propertyName">屬性名</param>
/// <param name="value">值</param>
/// <param name="operator">運算符</param>
public static Expression<Func<T, bool>> ParsePredicate<T>( string propertyName, object value, Operator @operator ) { var parameter = Expression.Parameter( typeof( T ), "t" ); return parameter.Property( propertyName ).Operation( @operator, value ).ToLambda<Func<T, bool>>( parameter ); } /// <summary>
/// 解析爲謂詞表達式 /// </summary>
/// <typeparam name="T">實體類型</typeparam>
/// <param name="predicateExpression">謂詞表達式字符串,參數佔位符爲@0,@1,@2 ...</param>
/// <param name="values">值</param>
public static Expression<Func<T, bool>> ParsePredicate<T>( string predicateExpression, params object[] values ) { return DynamicExpression.ParseLambda( typeof( T ), typeof( bool ), predicateExpression, values ) as Expression<Func<T, bool>>; } #endregion } }
在Util.Tests單元測試項目新建兩個測試樣例，代碼以下。測試
using System.ComponentModel.DataAnnotations; namespace Util.Tests.Samples { /// <summary>
/// 測試1 /// </summary>
public class Test1 { [StringLength( 20, ErrorMessage = "長度不能超過20" )] [Required( ErrorMessage = "名稱不能爲空" )] [Display( Name = "名稱" )] 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.ComponentModel.DataAnnotations; namespace Util.Tests.Samples { /// <summary>
/// 測試2 /// </summary>
[Serializable] public class Test2 { public Test2() { } public Test2( string name ) { Name = name; } [Required(ErrorMessage = "名稱不能爲空")] public string Name { get; set; } public int Int { get; set; } public int? NullableInt { get; set; } public decimal? NullableDecimal { get; set; } public decimal Decimal { get; set; } public TestA A { get; set; } [Serializable] 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; } } } } }
修改Util.Tests單元測試項目LambdaTest單元測試，代碼以下。ui
using System; using System.Collections.Generic; using System.ComponentModel.DataAnnotations; using System.Linq; using System.Linq.Expressions; using Microsoft.VisualStudio.TestTools.UnitTesting; using Util.Tests.Samples; namespace Util.Tests { /// <summary>
/// 表達式測試 /// </summary>
[TestClass] public class LambdaTest { #region GetName(獲取成員名稱)
/// <summary>
/// 獲取成員名稱 /// </summary>
[TestMethod] public void TestGetName() { //空值返回空字符串
Assert.AreEqual( "", Lambda.GetName( null ) ); //返回一級屬性名
Expression<Func<Test1, string>> expression = test => test.Name; Assert.AreEqual( "Name", Lambda.GetName( expression ) ); //返回二級屬性名
Expression<Func<Test1, string>> expression2 = test => test.A.Address; Assert.AreEqual( "A.Address", Lambda.GetName( expression2 ) ); //返回三級屬性名
Expression<Func<Test1, string>> expression3 = test => test.A.B.Name; Assert.AreEqual( "A.B.Name", Lambda.GetName( expression3 ) ); //測試可空整型
Expression<Func<Test1, int?>> expression4 = test => test.NullableInt; Assert.AreEqual( "NullableInt", Lambda.GetName( expression4 ) ); //測試類型轉換
Expression<Func<Test1, int?>> expression5 = test => test.Age; Assert.AreEqual( "Age", Lambda.GetName( expression5 ) ); } #endregion
#region GetValue(獲取成員值)
/// <summary>
/// 獲取成員值,委託返回類型爲Object /// </summary>
[TestMethod] public void TestGetValue_Object() { Expression<Func<Test1, 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<Test1, bool>> expression = test => test.Name == "A"; Assert.AreEqual( "A", Lambda.GetValue( expression ) ); //二級返回值
Expression<Func<Test1, bool>> expression2 = test => test.A.Integer == 1; Assert.AreEqual( 1, Lambda.GetValue( expression2 ) ); //三級返回值
Expression<Func<Test1, bool>> expression3 = test => test.A.B.Name == "B"; Assert.AreEqual( "B", Lambda.GetValue( expression3 ) ); } /// <summary>
/// 獲取可空類型的值 /// </summary>
[TestMethod] public void TestGetValue_Nullable() { //可空整型
Expression<Func<Test1, 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<Test1, 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 ) ); } /// <summary>
/// 從實例中獲取值 /// </summary>
[TestMethod] public void TestGetValue_Instance() { var test = new Test1() { Name = "a", A = new Test1.TestA() { Address = "b", B = new Test1.TestA.TestB() { Name = "c" } } }; //一級屬性
Expression<Func<string>> expression = () => test.Name; Assert.AreEqual( "a", Lambda.GetValue( expression ) ); //二級屬性
Expression<Func<string>> expression2 = () => test.A.Address; Assert.AreEqual( "b", Lambda.GetValue( expression2 ) ); //三級屬性
Expression<Func<string>> expression3 = () => test.A.B.Name; Assert.AreEqual( "c", Lambda.GetValue( expression3 ) ); } /// <summary>
/// 測試值爲複雜類型 /// </summary>
[TestMethod] public void TestGetValue_Complex() { var test = new Test1() { Name = "a", A = new Test1.TestA() { Address = "b" } }; //獲取表達式的值
Expression<Func<Test1, bool>> expression = t => t.Name == test.Name; Assert.AreEqual( "a", Lambda.GetValue( expression ), "==test.Name" ); Expression<Func<Test1, bool>> expression2 = t => t.Name == test.A.Address; Assert.AreEqual( "b", Lambda.GetValue( expression2 ), "==test.A.Address" ); //獲取方法的值
Expression<Func<Test1, bool>> expression3 = t => t.Name.Contains( test.Name ); Assert.AreEqual( "a", Lambda.GetValue( expression3 ), "Contains test.Name" ); Expression<Func<Test1, bool>> expression4 = t => t.Name.Contains( test.A.Address ); Assert.AreEqual( "b", Lambda.GetValue( expression4 ), "==test.A.Address" ); } #endregion
#region GetParameter(獲取參數)
/// <summary>
/// 獲取參數 /// </summary>
[TestMethod] public void TestGetParameter() { //空值返回null
Assert.AreEqual( null, Lambda.GetParameter( null ) ); //一級返回值
Expression<Func<Test1, object>> expression = test => test.Name == "A"; Assert.AreEqual( "test", Lambda.GetParameter( expression ).ToString() ); //二級返回值
Expression<Func<Test1, object>> expression2 = test => test.A.Integer == 1; Assert.AreEqual( "test", Lambda.GetParameter( expression2 ).ToString() ); //三級返回值
Expression<Func<Test1, object>> expression3 = test => test.A.B.Name == "B"; Assert.AreEqual( "test", Lambda.GetParameter( expression3 ).ToString() ); } #endregion
#region GetCriteriaCount(獲取謂詞條件的個數)
/// <summary>
/// 獲取謂詞條件的個數 /// </summary>
[TestMethod] public void TestGetCriteriaCount() { //0個條件
Assert.AreEqual( 0, Lambda.GetCriteriaCount( null ) ); //1個條件
Expression<Func<Test1, 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<Test1, 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
#region Equal(建立等於表達式)
/// <summary>
/// 建立等於表達式 /// </summary>
[TestMethod] public void TestEqual() { //一級屬性
Expression<Func<Test1, bool>> expected = t => t.Age == 1; Assert.AreEqual( expected.ToString(), Lambda.Equal<Test1>( "Age", 1 ).ToString() ); //二級屬性
Expression<Func<Test1, bool>> expected2 = t => t.A.Integer == 1; Assert.AreEqual( expected2.ToString(), Lambda.Equal<Test1>( "A.Integer", 1 ).ToString() ); } #endregion
#region NotEqual(建立不等於表達式)
/// <summary>
/// 建立不等於表達式 /// </summary>
[TestMethod] public void TestNotEqual() { //一級屬性
Expression<Func<Test1, bool>> expected = t => t.Age != 1; Assert.AreEqual( expected.ToString(), Lambda.NotEqual<Test1>( "Age", 1 ).ToString() ); //二級屬性
Expression<Func<Test1, bool>> expected2 = t => t.A.Integer != 1; Assert.AreEqual( expected2.ToString(), Lambda.NotEqual<Test1>( "A.Integer", 1 ).ToString() ); } #endregion
#region Greater(建立大於表達式)
/// <summary>
/// 建立大於表達式 /// </summary>
[TestMethod] public void TestGreater() { //一級屬性
Expression<Func<Test1, bool>> expected = t => t.Age > 1; Assert.AreEqual( expected.ToString(), Lambda.Greater<Test1>( "Age", 1 ).ToString() ); //二級屬性
Expression<Func<Test1, bool>> expected2 = t => t.A.Integer > 1; Assert.AreEqual( expected2.ToString(), Lambda.Greater<Test1>( "A.Integer", 1 ).ToString() ); } #endregion
#region Less(建立小於表達式)
/// <summary>
/// 建立小於表達式 /// </summary>
[TestMethod] public void TestLess() { //一級屬性
Expression<Func<Test1, bool>> expected = t => t.Age < 1; Assert.AreEqual( expected.ToString(), Lambda.Less<Test1>( "Age", 1 ).ToString() ); //二級屬性
Expression<Func<Test1, bool>> expected2 = t => t.A.Integer < 1; Assert.AreEqual( expected2.ToString(), Lambda.Less<Test1>( "A.Integer", 1 ).ToString() ); } #endregion
#region GreaterEqual(建立大於等於表達式)
/// <summary>
/// 建立大於等於表達式 /// </summary>
[TestMethod] public void TestGreaterEqual() { //一級屬性
Expression<Func<Test1, bool>> expected = t => t.Age >= 1; Assert.AreEqual( expected.ToString(), Lambda.GreaterEqual<Test1>( "Age", 1 ).ToString() ); //二級屬性
Expression<Func<Test1, bool>> expected2 = t => t.A.Integer >= 1; Assert.AreEqual( expected2.ToString(), Lambda.GreaterEqual<Test1>( "A.Integer", 1 ).ToString() ); } #endregion
#region LessEqual(建立小於等於表達式)
/// <summary>
/// 建立小於等於表達式 /// </summary>
[TestMethod] public void TestLessEqual() { //一級屬性
Expression<Func<Test1, bool>> expected = t => t.Age <= 1; Assert.AreEqual( expected.ToString(), Lambda.LessEqual<Test1>( "Age", 1 ).ToString() ); //二級屬性
Expression<Func<Test1, bool>> expected2 = t => t.A.Integer <= 1; Assert.AreEqual( expected2.ToString(), Lambda.LessEqual<Test1>( "A.Integer", 1 ).ToString() ); } #endregion
#region Contains(調用Contains方法)
/// <summary>
/// 調用Contains方法 /// </summary>
[TestMethod] public void TestContains() { //一級屬性
Expression<Func<Test1, bool>> expected = t => t.Name.Contains( "A" ); Assert.AreEqual( expected.ToString(), Lambda.Contains<Test1>( "Name", "A" ).ToString() ); //二級屬性
Expression<Func<Test1, bool>> expected2 = t => t.A.Address.Contains( "A" ); Assert.AreEqual( expected2.ToString(), Lambda.Contains<Test1>( "A.Address", "A" ).ToString() ); //三級屬性
Expression<Func<Test1, bool>> expected3 = t => t.A.B.Name.Contains( "A" ); Assert.AreEqual( expected3.ToString(), Lambda.Contains<Test1>( "A.B.Name", "A" ).ToString() ); } #endregion
#region Starts(調用StartsWith方法)
/// <summary>
/// 調用StartsWith方法 /// </summary>
[TestMethod] public void TestStarts() { //一級屬性
Expression<Func<Test1, bool>> expected = t => t.Name.StartsWith( "A" ); Assert.AreEqual( expected.ToString(), Lambda.Starts<Test1>( "Name", "A" ).ToString() ); //二級屬性
Expression<Func<Test1, bool>> expected2 = t => t.A.Address.StartsWith( "A" ); Assert.AreEqual( expected2.ToString(), Lambda.Starts<Test1>( "A.Address", "A" ).ToString() ); //三級屬性
Expression<Func<Test1, bool>> expected3 = t => t.A.B.Name.StartsWith( "A" ); Assert.AreEqual( expected3.ToString(), Lambda.Starts<Test1>( "A.B.Name", "A" ).ToString() ); } #endregion
#region Ends(調用EndsWith方法)
/// <summary>
/// 調用EndsWith方法 /// </summary>
[TestMethod] public void TestEnds() { //一級屬性
Expression<Func<Test1, bool>> expected = t => t.Name.EndsWith( "A" ); Assert.AreEqual( expected.ToString(), Lambda.Ends<Test1>( "Name", "A" ).ToString() ); //二級屬性
Expression<Func<Test1, bool>> expected2 = t => t.A.Address.EndsWith( "A" ); Assert.AreEqual( expected2.ToString(), Lambda.Ends<Test1>( "A.Address", "A" ).ToString() ); //三級屬性
Expression<Func<Test1, bool>> expected3 = t => t.A.B.Name.EndsWith( "A" ); Assert.AreEqual( expected3.ToString(), Lambda.Ends<Test1>( "A.B.Name", "A" ).ToString() ); } #endregion
#region GetConst(獲取常量表達式)
/// <summary>
/// 獲取常量表達式 /// </summary>
[TestMethod] public void TestGetConst() { Expression<Func<Test1, int?>> property = t => t.NullableInt; ConstantExpression constantExpression = Lambda.Constant( property, 1 ); Assert.AreEqual( typeof( int ), constantExpression.Type ); } #endregion
#region GetAttribute(獲取特性)
/// <summary>
/// 測試獲取特性 /// </summary>
[TestMethod] public void TestGetAttribute() { DisplayAttribute attribute = Lambda.GetAttribute<Test1, string, DisplayAttribute>( t => t.Name ); Assert.AreEqual( "名稱", attribute.Name ); } #endregion
#region GetAttributes(獲取特性列表)
/// <summary>
/// 測試獲取特性列表 /// </summary>
[TestMethod] public void TestGetAttributes() { IEnumerable<ValidationAttribute> attributes = Lambda.GetAttributes<Test1, string, ValidationAttribute>( t => t.Name ); Assert.AreEqual( 2, attributes.Count() ); } #endregion } }
這些操做方法的做用，你們本身看下測試就明白了，具體應用在後面介紹。spa
.Net應用程序框架交流QQ羣: 386092459，歡迎有興趣的朋友加入討論。code
謝謝你們的持續關注，個人博客地址：http://www.cnblogs.com/xiadao521/對象
下載地址：http://files.cnblogs.com/xiadao521/Util.2015.1.6.1.rarblog
相關文章
- 1. Util應用程序框架公共操做類(十二):Lambda表達式公共操做類(三)
- 2. Util應用程序框架公共操做類(七):Lambda表達式公共操做類
- 3. Util應用程序框架公共操做類(五):異常公共操做類
- 4. Util應用程序框架公共操做類(四):驗證公共操做類
- 5. Util應用程序框架公共操做類(九):Lambda表達式擴展
- 6. Util應用程序框架公共操做類(二):數據類型轉換公共操做類（源碼篇）
- 7. Util應用程序框架公共操做類(十一):表達式生成器
- 8. Util應用程序框架公共操做類(三):數據類型轉換公共操做類（擴展篇）
- 9. Util應用程序框架公共操做類(十):可空值類型擴展
- 10. Util應用程序框架公共操做類(六):驗證擴展
- 更多相關文章...
- • XML 應用程序 - XML 教程
- • SQLite 表達式 - SQLite教程
- • Kotlin學習（二）基本類型
- • RxJava操作符（八）Aggregate
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. No provider available from registry 127.0.0.1:2181 for service com.ddbuy.ser 解決方法
- 2. Qt5.7以上調用虛擬鍵盤(支持中文)，以及源碼修改(可拖動，水平縮放)
- 3. 軟件測試面試- 購物車功能測試用例設計
- 4. ElasticSearch（概念篇）：你知道的, 爲了搜索…
- 5. redux理解
- 6. gitee創建第一個項目
- 7. 支持向量機之硬間隔（一步步推導，通俗易懂）
- 8. Mysql 異步複製延遲的原因及解決方案
- 9. 如何在運行SEPM配置嚮導時將不可認的複雜數據庫密碼改爲簡單密碼
- 10. windows系統下tftp服務器使用
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. Util應用程序框架公共操做類(十二):Lambda表達式公共操做類(三)
- 2. Util應用程序框架公共操做類(七):Lambda表達式公共操做類
- 3. Util應用程序框架公共操做類(五):異常公共操做類
- 4. Util應用程序框架公共操做類(四):驗證公共操做類
- 5. Util應用程序框架公共操做類(九):Lambda表達式擴展
- 6. Util應用程序框架公共操做類(二):數據類型轉換公共操做類（源碼篇）
- 7. Util應用程序框架公共操做類(十一):表達式生成器
- 8. Util應用程序框架公共操做類(三):數據類型轉換公共操做類（擴展篇）
- 9. Util應用程序框架公共操做類(十):可空值類型擴展
- 10. Util應用程序框架公共操做類(六):驗證擴展