unit test

rename method in LinqHelp

Test/Vit.Linq.MsTest/QueryBuilder/IQueryable_QueryBuilder_Test.cs

@@ -2,13 +2,17 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System.Collections.Generic;
 using System.Linq;
+using Vit.Core.Module.Serialization;
+using Vit.Linq.QueryBuilder;
+using Vit.Linq.MsTest.Extensions;
 
 namespace Vit.Linq.MsTest
 {
+
     [TestClass]
     public class IQueryable_QueryBuilder_Test
     {
-        IQueryable  GetQueryable() => DataSource.GetIQueryable();
+        IQueryable GetQueryable() => DataSource.GetIQueryable();
 
 
         [TestMethod]
@@ -40,212 +44,412 @@ namespace Vit.Linq.MsTest
         }
 
 
-        /*
-
-        #region (x.2)DataFilter        
+        #region Test_FilterRule
         [TestMethod]
-        public void TestDataFilter()
+        public void Test_FilterRule()
         {
-            var query = DataSource.GetIQueryable();
 
-         
- 
+            #region #1 [object] is null | is not null
+
+            #region ##1 is null
+            {
+                var query = GetQueryable();
+
+                var item = query.Skip(10).FirstOrDefault();
+                item.name = null;
+
+                var strRule = "{'field':'name',  'operator': 'is null'  }".Replace("'", "\"");
+                var rule = Json.Deserialize<FilterRule>(strRule);
+                var result = query.Where(rule).ToList();
+                Assert.AreEqual(1, result.Count);
+                Assert.AreEqual(10, result[0].id);
+            }
+            #endregion
 
-            #region (x.1)  =
+            #region ##2 is not null
             {
+                var query = GetQueryable();
+
+                var item = query.Skip(10).FirstOrDefault();
+                item.name = null;
+
+                var strRule = "{'field':'name',  'operator': 'is not null'  }".Replace("'", "\"");
+                var rule = Json.Deserialize<FilterRule>(strRule);
+                var result = query.Where(rule).ToList();
+                Assert.AreEqual(999, result.Count);
+            }
+            #endregion
+
+            #endregion
 
-                //(x.x.1)
+
+            #region #2 [number | string | bool] compare
+
+            #region ##1.1 [number] =
+            {
+                // ###1
                 {
-                    var result = query.IQueryable_Where(new[] { new DataFilter { field = "id", opt = "=", value = 10 } }).IQueryable_ToList<ModelA>();
-                    Assert.AreEqual(result.Count, 1);
-                    Assert.AreEqual(result[0].id, 10);
+                    var query = GetQueryable();
+
+                    var strRule = "{'field':'id',  'operator': '=',  'value':10 }".Replace("'", "\"");
+                    var rule = Json.Deserialize<FilterRule>(strRule);
+                    var result = query.Where(rule).ToList();
+                    Assert.AreEqual(1, result.Count);
+                    Assert.AreEqual(10, result[0].id);
                 }
 
-                //(x.x.2) == null
+                // ###2
                 {
-                    var item = query.IQueryable_Skip(10).IQueryable_FirstOrDefault<ModelA>();
-                    var pid = item.pid;
+                    var query = GetQueryable();
+
+                    var strRule = "{'field':'id',  'operator': '=',  'value': '10' }".Replace("'", "\"");
+                    var rule = Json.Deserialize<FilterRule>(strRule);
+                    var result = query.Where(rule).ToList();
+                    Assert.AreEqual(1, result.Count);
+                    Assert.AreEqual(10, result[0].id);
+                }
+
+
+                // ###3  = null
+                {
+                    var query = GetQueryable();
+
+                    var item = query.Skip(10).FirstOrDefault();
                     item.pid = null;
 
-                    var result = query.IQueryable_Where(new[] { new DataFilter { field = "pid", opt = "=", value = null } }).IQueryable_FirstOrDefault<ModelA>();
-                    Assert.AreEqual(result?.id, 10);
-                    item.pid = pid;
+                    var strRule = "{'field':'pid',  'operator': '=',  'value': null }".Replace("'", "\"");
+                    var rule = Json.Deserialize<FilterRule>(strRule);
+                    var result = query.Where(rule).FirstOrDefault();
+                    Assert.AreEqual(10, result.id);
                 }
+
+
             }
             #endregion
 
+            #region ##1.2 [bool] =
+            {
+                // ###1
+                {
+                    var query = GetQueryable();
+
+                    var strRule = "{'field':'isEven',  'operator': '=',  'value':true }".Replace("'", "\"");
+                    var rule = Json.Deserialize<FilterRule>(strRule);
+                    var result = query.Where(rule).ToList();
+                    Assert.AreEqual(result.Count, 500);
+                    Assert.AreEqual(0, result[0].id);
+                }
+
+                // ###2
+                {
+                    var query = GetQueryable();
+
+                    var strRule = "{'field':'isEven',  'operator': '=',  'value': 'false' }".Replace("'", "\"");
+                    var rule = Json.Deserialize<FilterRule>(strRule);
+                    var result = query.Where(rule).ToList();
+                    Assert.AreEqual(result.Count, 500);
+                    Assert.AreEqual(1, result[0].id);
+                }
+            }
+            #endregion
 
-            #region (x.2)  !=
+            #region ##2.1 [number] !=
             {
-                //(x.x.1)
+                // ###1
                 {
-                    var result = query.IQueryable_Where(new[] { new DataFilter { field = "id", opt = "!=", value = 10 } }).IQueryable_ToList<ModelA>();
-                    Assert.AreEqual(result.Count, 999);
+                    var query = GetQueryable();
+
+                    var strRule = "{'field':'id',  'operator': '!=',  'value':10 }".Replace("'", "\"");
+                    var rule = Json.Deserialize<FilterRule>(strRule);
+                    var result = query.Where(rule).ToList();
+                    Assert.AreEqual(999, result.Count);
                 }
 
-                //(x.x.2) != null
+                // ###2 != null
                 {
-                    var item = query.IQueryable_Skip(10).IQueryable_FirstOrDefault<ModelA>();
-                    var pid = item.pid;
+                    var query = GetQueryable();
+
+                    var item = query.Skip(10).FirstOrDefault();
                     item.pid = null;
 
-                    var result = query.IQueryable_Where(new[] { new DataFilter { field = "pid", opt = "!=", value = null } }).IQueryable_ToList<ModelA>();
-                    Assert.AreEqual(result.Count, 999);
-                    item.pid = pid;
+                    var strRule = "{'field':'pid',  'operator': '!=',  'value': null }".Replace("'", "\"");
+                    var rule = Json.Deserialize<FilterRule>(strRule);
+                    var result = query.Where(rule).ToList();
+                    Assert.AreEqual(999, result.Count);
                 }
             }
             #endregion
 
-            #region (x.3)  > <
+            #region ##2.2 [bool] !=
             {
-                var result = query.IQueryable_Where(new[] { new DataFilter { field = "id", opt = ">", value = 10 }, new DataFilter { field = "id", opt = "<", value = 20 } }).IQueryable_ToList<ModelA>();
-                Assert.AreEqual(result.Count, 9);
+                // ###1
+                {
+                    var query = GetQueryable();
+
+                    var strRule = "{'field':'isEven',  'operator': '!=',  'value':true }".Replace("'", "\"");
+                    var rule = Json.Deserialize<FilterRule>(strRule);
+                    var result = query.Where(rule).ToList();
+                    Assert.AreEqual(result.Count, 500);
+                    Assert.AreEqual(1, result[0].id);
+                }
+
+                // ###2
+                {
+                    var query = GetQueryable();
+
+                    var strRule = "{'field':'isEven',  'operator': '!=',  'value': 'false' }".Replace("'", "\"");
+                    var rule = Json.Deserialize<FilterRule>(strRule);
+                    var result = query.Where(rule).ToList();
+                    Assert.AreEqual(result.Count, 500);
+                    Assert.AreEqual(0, result[0].id);
+                }
             }
             #endregion
 
-            #region (x.4)  >= <=
+
+            #region ##3 [number] > <
             {
-                var result = query.IQueryable_Where(new[] { new DataFilter { field = "id", opt = ">=", value = 10 }, new DataFilter { field = "id", opt = "<=", value = 20 } }).IQueryable_ToList<ModelA>();
-                Assert.AreEqual(result.Count, 11);
+                {
+                    var query = GetQueryable();
+
+                    var strRule = @"{'condition':'and', 'rules':[   
+                                        {'field':'id',  'operator': '>',  'value':10  },
+                                        {'field':'id',  'operator': '<',  'value': '20' } 
+                                    ]}".Replace("'", "\"");
+                    var rule = Json.Deserialize<FilterRule>(strRule);
+                    var result = query.Where(rule).ToList();
+                    Assert.AreEqual(9, result.Count);
+                    Assert.AreEqual(11, result[0].id);
+                }
             }
             #endregion
 
 
-            #region (x.5)  Contains
+            #region ##4 [number] >= <=
             {
-                var result = query.IQueryable_Where(new[] { new DataFilter { field = "name", opt = "Contains", value = "987" } }).IQueryable_ToList<ModelA>();
-                Assert.AreEqual(result.Count, 1);
-                Assert.AreEqual(result[0].id, 987);
+                {
+                    var query = GetQueryable();
+
+                    var strRule = @"{'condition':'and', 'rules':[   
+                                        {'field':'id',  'operator': '>=',  'value':10  },
+                                        {'field':'id',  'operator': '<=',  'value': '20' } 
+                                    ]}".Replace("'", "\"");
+                    var rule = Json.Deserialize<FilterRule>(strRule);
+                    var result = query.Where(rule).ToList();
+                    Assert.AreEqual(11, result.Count);
+                    Assert.AreEqual(10, result[0].id);
+                }
             }
             #endregion
 
-            #region (x.x)  NotContains
-            {
+            #endregion
+
+
+            #region #3  in | not in
 
-                //(x.x.1)
+            #region ##1 in
+            {
                 {
-                    var result = query.IQueryable_Where(new[] { new DataFilter { field = "name", opt = "NotContains", value = "987" } }).IQueryable_ToList<ModelA>();
-                    Assert.AreEqual(result.Count, 999);
-                }
+                    var query = GetQueryable();
 
+                    var strRule = "{'field':'id',  'operator': 'in',  'value': [3,4,5] }".Replace("'", "\"");
+                    var rule = Json.Deserialize<FilterRule>(strRule);
+                    var result = query.Where(rule).ToList();
+                    Assert.AreEqual(3, result.Count);
+                    Assert.AreEqual(5, result[2].id);
+                }
 
-                //(x.x.2)
                 {
-                    var item = query.IQueryable_Where(
-                        new[] { new DataFilter { field = "name", opt = "Contains",value="987" } }
-                        ).IQueryable_FirstOrDefault<ModelA>();
-                    var oriName = item.name;
-
-                    item.name = null;
-                    var result = query.IQueryable_Where(new[] { new DataFilter { field = "name", opt = "NotContains", value = "987" } }).IQueryable_ToList<ModelA>();
-                    Assert.AreEqual(result.Count, 1000);
-                    item.name = oriName;
+                    var query = GetQueryable();
+
+                    var strRule = "{'field':'name',  'operator': 'in',  'value': [ 'name3', 'name4'] }".Replace("'", "\"");
+                    var rule = Json.Deserialize<FilterRule>(strRule);
+                    var result = query.Where(rule).ToList();
+                    Assert.AreEqual(2, result.Count);
+                    Assert.AreEqual("name3", result[0].name);
                 }
 
-                //(x.x.3)
                 {
-                    var item = query.IQueryable_Where(
-                        new[] { new DataFilter { field = "name", opt = "Contains", value = "987" } }
-                        ).IQueryable_FirstOrDefault<ModelA>();
-                    var oriName = item.name;
-
-                    item.name = "";
-                    var result = query.IQueryable_Where(new[] { new DataFilter { field = "name", opt = "NotContains", value = "987" } }).IQueryable_ToList<ModelA>();
-                    Assert.AreEqual(result.Count, 1000);
-                    item.name = oriName;
+                    var query = GetQueryable();
+                    query.FirstOrDefault().name = null;
+
+                    var strRule = @"{'condition':'or', 'rules':[
+                                        {'field':'name',  'operator': 'is null' },
+                                        {'field':'name',  'operator': 'in',  'value': [ 'name3', 'name4'] } 
+                                    ]}".Replace("'", "\"");
+                    var rule = Json.Deserialize<FilterRule>(strRule);
+                    var result = query.Where(rule).ToList();
+                    Assert.AreEqual(3, result.Count);
+                    Assert.AreEqual(null, result[0].name);
+                    Assert.AreEqual("name4", result[2].name);
                 }
             }
             #endregion
 
-            #region (x.6)  StartsWith
+            #region ##2  not in 
             {
-                var result = query.IQueryable_Where(new[] { new DataFilter { field = "name", opt = "StartsWith", value = "name98" } }).IQueryable_ToList<ModelA>();
-                Assert.AreEqual(result.Count, 11);
+                var query = GetQueryable();
+                query.FirstOrDefault().name = null;
+
+                var strRule = @"{'condition':'and', 'rules':[   
+                                        {'field':'name',  'operator': 'is not null' },
+                                        {'field':'name',  'operator': 'not in',  'value': [ 'name3', 'name4'] } 
+                                    ]}".Replace("'", "\"");
+                var rule = Json.Deserialize<FilterRule>(strRule);
+                var result = query.Where(rule).ToList();
+                Assert.AreEqual(997, result.Count);
             }
             #endregion
 
-            #region (x.7)  EndsWith
+            #endregion
+
+
+            #region #4 [string] operate
+
+            #region ##1  contains
             {
-                var result = query.IQueryable_Where(new[] { new DataFilter { field = "name", opt = "EndsWith", value = "987" } }).IQueryable_ToList<ModelA>();
-                Assert.AreEqual(result.Count, 1);
+                var query = GetQueryable();
+
+                var strRule = "{'field':'name',  'operator': 'contains',  'value': '987' }".Replace("'", "\"");
+                var rule = Json.Deserialize<FilterRule>(strRule);
+                var result = query.Where(rule).ToList();
+
+                Assert.AreEqual(1, result.Count);
+                Assert.AreEqual(987, result.First().id);
             }
             #endregion
 
-            #region (x.x)  IsNullOrEmpty
+            #region ##2  not contains
             {
-                var item = query.IQueryable_Skip(10).IQueryable_FirstOrDefault<ModelA>();
-                var oriName = item.name;
+                //###1
+                {
+                    var query = GetQueryable();
+
+                    var strRule = "{'field':'name',  'operator': 'not contains',  'value': '987' }".Replace("'", "\"");
+                    var rule = Json.Deserialize<FilterRule>(strRule);
+                    var result = query.Where(rule).ToList();
+                    Assert.AreEqual(999, result.Count);
+                }
+
 
-                //(x.x.1)
+                //###2
                 {
-                    item.name = null;
-                    var result = query.IQueryable_Where(new[] { new DataFilter { field = "name", opt = "IsNullOrEmpty" } }).IQueryable_ToList<ModelA>();
-                    Assert.AreEqual(result.Count, 1);
-                    item.name = oriName;
+                    var query = GetQueryable();
+                    query.Skip(987).FirstOrDefault().name = null;
+
+                    var strRule = "{'field':'name',  'operator': 'not contains',  'value': '987' }".Replace("'", "\"");
+                    var rule = Json.Deserialize<FilterRule>(strRule);
+                    var result = query.Where(rule).ToList();
+                    Assert.AreEqual(1000, result.Count);
                 }
-                //(x.x.2)
+
+                //###3
                 {
-                    item.name = "";
-                    var result = query.IQueryable_Where(new[] { new DataFilter { field = "name", opt = "IsNullOrEmpty" } }).IQueryable_ToList<ModelA>();
-                    Assert.AreEqual(result.Count, 1);
-                    item.name = oriName;
+                    var query = GetQueryable();
+                    query.Skip(987).FirstOrDefault().name = "";
+
+                    var strRule = "{'field':'name',  'operator': 'not contains',  'value': '987' }".Replace("'", "\"");
+                    var rule = Json.Deserialize<FilterRule>(strRule);
+                    var result = query.Where(rule).ToList();
+                    Assert.AreEqual(1000, result.Count);
                 }
             }
             #endregion
 
-            #region (x.x)  IsNotNullOrEmpty
+            #region ##3  starts with
             {
-                var item = query.IQueryable_Skip(10).IQueryable_FirstOrDefault<ModelA>();
-                var oriName = item.name;
+                var query = GetQueryable();
 
-                //(x.x.1)
-                {
-                    item.name = null;
-                    var result = query.IQueryable_Where(
-                        new[] { new DataFilter { field = "name", opt = "IsNotNullOrEmpty" } }
-                        )
-                        .IQueryable_ToList<ModelA>();
-                    Assert.AreEqual(result.Count, 999);
-                    item.name = oriName;
-                }
-                //(x.x.2)
-                {
-                    item.name = "";
-                    var result = query.IQueryable_Where(new[] { new DataFilter { field = "name", opt = "IsNotNullOrEmpty" } }).IQueryable_ToList<ModelA>();
-                    Assert.AreEqual(result.Count, 999);
-                    item.name = oriName;
-                }
+                var strRule = "{'field':'name',  'operator': 'starts with',  'value': 'name98' }".Replace("'", "\"");
+                var rule = Json.Deserialize<FilterRule>(strRule);
+                var result = query.Where(rule).ToList();
+
+                Assert.AreEqual(11, result.Count);
             }
             #endregion
 
-            #region (x.8)  In 1
+            #region ##4  ends with
             {
-                var result = query.IQueryable_Where(new[] { new DataFilter { field = "id", opt = "In", value = new int[] { 3, 4, 5 } } }).IQueryable_ToList<ModelA>();
-                Assert.AreEqual(result.Count, 3);
+                var query = GetQueryable();
+
+                var strRule = "{'field':'name',  'operator': 'ends with',  'value': '987' }".Replace("'", "\"");
+                var rule = Json.Deserialize<FilterRule>(strRule);
+                var result = query.Where(rule).ToList();
+
+                Assert.AreEqual(1, result.Count);
             }
             #endregion
 
-            #region (x.9)  In 2
+            #region ##5 is null or empty
             {
-                query.IQueryable_FirstOrDefault<ModelA>().name = null;
-                var result = query.IQueryable_Where(new[] { new DataFilter { field = "name", opt = "In", value = new[] { "name3", "name4", null } } }).IQueryable_ToList<ModelA>();
-                Assert.AreEqual(result.Count, 3);
+                //###1
+                {
+                    var query = GetQueryable();
+                    query.Skip(10).FirstOrDefault().name = null;
+
+                    var strRule = "{'field':'name',  'operator': 'is null or empty' }".Replace("'", "\"");
+                    var rule = Json.Deserialize<FilterRule>(strRule);
+                    var result = query.Where(rule).ToList();
+
+                    Assert.AreEqual(1, result.Count);
+
+                }
+
+                //###2
+                {
+                    var query = GetQueryable();
+                    query.Skip(10).FirstOrDefault().name = "";
+
+                    var strRule = "{'field':'name',  'operator': 'is null or empty' }".Replace("'", "\"");
+                    var rule = Json.Deserialize<FilterRule>(strRule);
+                    var result = query.Where(rule).ToList();
+
+                    Assert.AreEqual(1, result.Count);
+                }
             }
             #endregion
 
-            #region (x.10)  NotIn 
+            #region ##6  is not null or empty
             {
-                var result = query.IQueryable_Where(new[] { new DataFilter { field = "name", opt = "NotIn", value = new[] { "name3", "name4", null } } }).IQueryable_ToList<ModelA>();
-                Assert.AreEqual(result.Count, 997);
+                //###1
+                {
+                    var query = GetQueryable();
+                    query.Skip(10).FirstOrDefault().name = null;
+
+                    var strRule = "{'field':'name',  'operator': 'is not null or empty' }".Replace("'", "\"");
+                    var rule = Json.Deserialize<FilterRule>(strRule);
+                    var result = query.Where(rule).ToList();
+
+                    Assert.AreEqual(999, result.Count);
+                }
+                //###2
+                {
+                    var query = GetQueryable();
+                    query.Skip(10).FirstOrDefault().name = "";
+
+                    var strRule = "{'field':'name',  'operator': 'is not null or empty' }".Replace("'", "\"");
+                    var rule = Json.Deserialize<FilterRule>(strRule);
+                    var result = query.Where(rule).ToList();
+
+                    Assert.AreEqual(999, result.Count);
+                }
             }
             #endregion
 
 
-            #region (x.11)  多级field
+            #endregion
+
+
+            #region #5  nested field
             {
-                var result = query.IQueryable_Where(new[] { new DataFilter { field = "b1.name", opt = "=", value = "name987_b1" } }).IQueryable_ToList<ModelA>();
-                Assert.AreEqual(result.Count, 1);
-                Assert.AreEqual(result[0].id, 987);
+                var query = GetQueryable();
+                var strRule = "{'field':'b1.name',  'operator': '=',  'value': 'name987_b1' }".Replace("'", "\"");
+                var rule = Json.Deserialize<FilterRule>(strRule);
+
+                var result = query.Where(rule).ToList();
+
+                Assert.AreEqual(1, result.Count);
+                Assert.AreEqual(987, result[0].id);
             }
             #endregion
 
@@ -253,10 +457,21 @@ namespace Vit.Linq.MsTest
 
         #endregion
 
-        //*/
+    }
+}
+
+
 
-   
 
+namespace Vit.Linq.MsTest.Extensions
+{
+    static class IQueryableExtensions
+    {
+        public static IQueryable Where(this IQueryable source, IFilterRule rule) => source.IQueryable_Where(rule);
+
+        public static IQueryable Skip(this IQueryable source, int count) => source.IQueryable_Skip(count);
 
+        public static ModelA FirstOrDefault(this IQueryable source) => source.IQueryable_FirstOrDefault<ModelA>();
+        public static List<ModelA> ToList(this IQueryable source) => source.IQueryable_ToList<ModelA>();
     }
 }

Test/Vit.Linq.MsTest/QueryBuilder/Queryable_QueryBuilder_Test.cs

@@ -47,9 +47,9 @@ namespace Vit.Linq.MsTest.QueryBuilder
 
 
 
-        #region QueryBuilder
+        #region Test_FilterRule
         [TestMethod]
-        public void Test_QueryBuilder()
+        public void Test_FilterRule()
         {
 
             #region #1 [object] is null | is not null
@@ -338,7 +338,7 @@ namespace Vit.Linq.MsTest.QueryBuilder
                 //###2
                 {
                     var query = GetQueryable();
-                    query.Where(m => m.name.Contains("987")).FirstOrDefault().name = null;
+                    query.Skip(987).FirstOrDefault().name = null;
 
                     var strRule = "{'field':'name',  'operator': 'not contains',  'value': '987' }".Replace("'", "\"");
                     var rule = Json.Deserialize<FilterRule>(strRule);
@@ -349,7 +349,7 @@ namespace Vit.Linq.MsTest.QueryBuilder
                 //###3
                 {
                     var query = GetQueryable();
-                    query.Where(m => m.name.Contains("987")).FirstOrDefault().name = "";
+                    query.Skip(987).FirstOrDefault().name = "";
 
                     var strRule = "{'field':'name',  'operator': 'not contains',  'value': '987' }".Replace("'", "\"");
                     var rule = Json.Deserialize<FilterRule>(strRule);
@@ -388,7 +388,7 @@ namespace Vit.Linq.MsTest.QueryBuilder
                 //###1
                 {
                     var query = GetQueryable();
-                    query.Skip(10).First().name = null;
+                    query.Skip(10).FirstOrDefault().name = null;
 
                     var strRule = "{'field':'name',  'operator': 'is null or empty' }".Replace("'", "\"");
                     var rule = Json.Deserialize<FilterRule>(strRule);
@@ -401,7 +401,7 @@ namespace Vit.Linq.MsTest.QueryBuilder
                 //###2
                 {
                     var query = GetQueryable();
-                    query.Skip(10).First().name = "";
+                    query.Skip(10).FirstOrDefault().name = "";
 
                     var strRule = "{'field':'name',  'operator': 'is null or empty' }".Replace("'", "\"");
                     var rule = Json.Deserialize<FilterRule>(strRule);
@@ -417,7 +417,7 @@ namespace Vit.Linq.MsTest.QueryBuilder
                 //###1
                 {
                     var query = GetQueryable();
-                    query.Skip(10).First().name = null;
+                    query.Skip(10).FirstOrDefault().name = null;
 
                     var strRule = "{'field':'name',  'operator': 'is not null or empty' }".Replace("'", "\"");
                     var rule = Json.Deserialize<FilterRule>(strRule);
@@ -428,7 +428,7 @@ namespace Vit.Linq.MsTest.QueryBuilder
                 //###2
                 {
                     var query = GetQueryable();
-                    query.Skip(10).First().name = "";
+                    query.Skip(10).FirstOrDefault().name = "";
 
                     var strRule = "{'field':'name',  'operator': 'is not null or empty' }".Replace("'", "\"");
                     var rule = Json.Deserialize<FilterRule>(strRule);

Vit.Linq.QueryBuilder/Doc/说明.txt

@@ -1,4 +0,0 @@
-参考 https://www.cnblogs.com/seriawei/p/entity-framework-dynamic-search.html 
-
-
-参考 DynamicQueryable

Vit.Linq.QueryBuilder/LinqHelp.Reflection.cs

@@ -1,17 +1,13 @@
 using System;
 using System.Linq.Expressions;
 using System.Reflection;
-using System.Runtime.CompilerServices;
 
 namespace Vit.Linq.QueryBuilder
 {
     public partial class LinqHelp
     {
 
-        #region BuildField_LambdaExpression
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Func<T, object> BuildField_Selector_ByReflection<T>(Func<T, object> before, string fieldName)
+        public static Func<T, object> GetFieldSelector_ByReflection<T>(Func<T, object> before, string fieldName)
         {
             return (T ori) =>
             {
@@ -20,45 +16,42 @@ namespace Vit.Linq.QueryBuilder
                 if (midValue == null) return null;
 
                 var midType = midValue.GetType();
-                //(x.1)property
+                //#1 property
                 var property = midType.GetProperty(fieldName);
                 if (property != null && property.CanRead)
                 {
                     return property.GetValue(midValue);
                 }
 
-                //(x.2)field
+                //#2 field
                 var field = midType.GetField(fieldName, BindingFlags.Public | BindingFlags.Instance);
                 if (field != null)
                 {
                     return field.GetValue(midValue);
                 }
 
-                //(x.3) null
+                //#3 null
                 return null;
             };
         }
 
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Func<T, object> BuildField_Selector_ByReflection<T>(string fieldPath)
+        public static Func<T, object> GetFieldSelector_ByReflection<T>(string fieldPath)
         {
             Func<T, object> getField = null;
             foreach (var fieldName in fieldPath?.Split('.'))
             {
-                getField = BuildField_Selector_ByReflection(getField, fieldName);
+                getField = GetFieldSelector_ByReflection(getField, fieldName);
             }
             return getField;
         }
 
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Expression<Func<T, object>> BuildField_LambdaExpression_ByReflection<T>(string fieldPath)
+        public static Expression<Func<T, object>> GetFieldExpression_ByReflection<T>(string fieldPath)
         {
-            Func<T, object> getField = BuildField_Selector_ByReflection<T>(fieldPath);
+            Func<T, object> getField = GetFieldSelector_ByReflection<T>(fieldPath);
             return t => getField(t);
         }
-        #endregion
+
 
     }
 }

Vit.Linq.QueryBuilder/LinqHelp.cs

@@ -1,14 +1,12 @@
 using System;
 using System.Linq.Expressions;
-using System.Runtime.CompilerServices;
 
 namespace Vit.Linq.QueryBuilder
 {
     public partial class LinqHelp
     {
-        #region BuildField      
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static MemberExpression BuildField_MemberExpression_ByName(Expression parameter, string propertyOrFieldName)
+
+        public static MemberExpression GetFieldMemberExpression_ByName(Expression parameter, string propertyOrFieldName)
         {
             return Expression.PropertyOrField(parameter, propertyOrFieldName);
         }
@@ -17,15 +15,14 @@ namespace Vit.Linq.QueryBuilder
         /// 
         /// </summary>
         /// <param name="parameter"></param>
-        /// <param name="fieldPath">可多级。例如 "name" 、 "depart.name"</param>
+        /// <param name="fieldPath"> could be nasted , example: "name"  "depart.name"</param>
         /// <returns></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static MemberExpression BuildField_MemberExpression(ParameterExpression parameter, string fieldPath)
+        public static MemberExpression GetFieldMemberExpression(ParameterExpression parameter, string fieldPath)
         {
             MemberExpression memberExp = null;
             foreach (var fieldName in fieldPath?.Split('.'))
             {
-                memberExp = BuildField_MemberExpression_ByName(((Expression)memberExp) ?? parameter, fieldName);
+                memberExp = GetFieldMemberExpression_ByName(((Expression)memberExp) ?? parameter, fieldName);
             }
             return memberExp;
         }
@@ -35,28 +32,22 @@ namespace Vit.Linq.QueryBuilder
         /// 
         /// </summary>
         /// <param name="type"></param>
-        /// <param name="fieldPath">可多级。例如 "name" 、 "depart.name"</param>
+        /// <param name="fieldPath"> could be nasted , example: "name"  "depart.name"</param>
         /// <returns></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static MemberExpression BuildField_MemberExpression(Type type, string fieldPath)
+        public static MemberExpression GetFieldMemberExpression(Type type, string fieldPath)
         {
-            return BuildField_MemberExpression(Expression.Parameter(type), fieldPath);
+            return GetFieldMemberExpression(Expression.Parameter(type), fieldPath);
         }
 
-        #endregion
-
 
 
-        #region BuildField_Selector
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Expression<Func<T, object>> BuildField_LambdaExpression<T>(string fieldPath)
+        public static Expression<Func<T, object>> GetFieldExpression<T>(string fieldPath)
         {
             var parammeter = Expression.Parameter(typeof(T));
-            MemberExpression memberExp = BuildField_MemberExpression(parammeter, fieldPath);
+            MemberExpression memberExp = GetFieldMemberExpression(parammeter, fieldPath);
             var lambda = Expression.Lambda(memberExp, parammeter).Compile();
             return t => lambda.DynamicInvoke(t);
         }
-        #endregion
 
 
 

Vit.Linq.QueryBuilder/QueryBuilder.cs

@@ -65,7 +65,7 @@ namespace Vit.Linq.QueryBuilder
                 return null;
             }
 
-            MemberExpression memberExp = LinqHelp.BuildField_MemberExpression(parameter, rule.field);
+            MemberExpression memberExp = LinqHelp.GetFieldMemberExpression(parameter, rule.field);
 
             #region get Expression
 

Vit.Linq.QueryBuilder/Vit.Linq.QueryBuilder.csproj

@@ -1,26 +1,24 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-	<PropertyGroup>
-		<pack>nuget</pack>
-	</PropertyGroup>
+    <PropertyGroup>
+        <pack>nuget</pack>
+    </PropertyGroup>
 
-	<PropertyGroup>
-		<TargetFramework>netstandard2.0</TargetFramework>
-		<Version>2.2.14-temp</Version>
-	</PropertyGroup>
+    <PropertyGroup>
+        <TargetFramework>netstandard2.0</TargetFramework>
+        <Version>2.2.14-temp</Version>
+    </PropertyGroup>
 
-	<PropertyGroup>
-		<Authors>Lith</Authors>
-		<Description>对Linq的扩展</Description>
-		<PackageProjectUrl>https://github.com/serset/Vit.Library</PackageProjectUrl>
-	</PropertyGroup>
+    <PropertyGroup>
+        <Authors>Lith</Authors>
+        <Description>Linq extensions (QueryBuilder)</Description>
+        <PackageProjectUrl>https://github.com/serset/Vit.Library</PackageProjectUrl>
+    </PropertyGroup>
+
+    <PropertyGroup>
+        <DocumentationFile>bin\Debug\netstandard2.0\Vit.Linq.QueryBuilder</DocumentationFile>
+    </PropertyGroup>
 
-	<PropertyGroup>
-		<DocumentationFile>bin\Debug\netstandard2.0\Vit.Linq.xml</DocumentationFile>
-	</PropertyGroup>
 
-	<ItemGroup>
-		<PackageReference Include="Vit.Core" Version="2.1.19" />
-	</ItemGroup>
 
 </Project>

Vit.Linq.QueryBuilder/readme.md

@@ -0,0 +1,3 @@
+ref https://www.cnblogs.com/seriawei/p/entity-framework-dynamic-search.html 
+
+ref DynamicQueryable

Vit.Linq/Extensions/IQueryable_SortExtensions.cs

@@ -41,7 +41,7 @@ namespace Vit.Extensions.Linq_Extensions
             foreach (var item in sort)
             {
                 //(x.1)get memberExp     
-                MemberExpression memberExp = LinqHelp.BuildField_MemberExpression(parameter, item.field);
+                MemberExpression memberExp = LinqHelp.GetFieldMemberExpression(parameter, item.field);
 
 
                 #region (x.2)Call

Vit.Linq/Extensions/Queryable_SortExtensions.cs

@@ -31,7 +31,7 @@ namespace Vit.Extensions.Linq_Extensions
             foreach (var item in sort)
             {
 
-                MemberExpression memberExp = LinqHelp.BuildField_MemberExpression(paramExp, item.field);
+                MemberExpression memberExp = LinqHelp.GetFieldMemberExpression(paramExp, item.field);
                 LambdaExpression exp = Expression.Lambda(memberExp, paramExp);
 
                 if (orderedQuery == null)
@@ -62,7 +62,7 @@ namespace Vit.Extensions.Linq_Extensions
             if (string.IsNullOrEmpty(field)) return query;
 
             var paramExp = Expression.Parameter(typeof(T));
-            MemberExpression memberExp = LinqHelp.BuildField_MemberExpression(paramExp, field);
+            MemberExpression memberExp = LinqHelp.GetFieldMemberExpression(paramExp, field);
             LambdaExpression expr = Expression.Lambda(memberExp, paramExp);
 
             return OrderBy(query, expr, asc);

Vit.Linq/Extensions/Queryable_Sort_ByReflection_Extensions.cs

@@ -24,7 +24,7 @@ namespace Vit.Extensions.Linq_Extensions
             IOrderedQueryable<T> orderedQuery = null;
             foreach (var item in sort)
             {
-                var keySelector = LinqHelp.BuildField_LambdaExpression_ByReflection<T>(item.field);
+                var keySelector = LinqHelp.GetFieldExpression_ByReflection<T>(item.field);
 
                 if (keySelector == null)
                 {
@@ -71,7 +71,7 @@ namespace Vit.Extensions.Linq_Extensions
         {
             if (query == null) return query;
 
-            var keySelector = LinqHelp.BuildField_LambdaExpression_ByReflection<T>(field);
+            var keySelector = LinqHelp.GetFieldExpression_ByReflection<T>(field);
 
             if (keySelector == null)
             {

Vit.Linq/Vit.Linq.csproj

@@ -1,30 +1,30 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-	<PropertyGroup>
-		<pack>nuget</pack>
-	</PropertyGroup>
+    <PropertyGroup>
+        <pack>nuget</pack>
+    </PropertyGroup>
 
-	<PropertyGroup>
-		<TargetFramework>netstandard2.0</TargetFramework>
-		<Version>2.2.14-temp</Version>
-	</PropertyGroup>
+    <PropertyGroup>
+        <TargetFramework>netstandard2.0</TargetFramework>
+        <Version>2.2.14-temp</Version>
+    </PropertyGroup>
 
-	<PropertyGroup>
-		<Authors>Lith</Authors>
-		<Description>对Linq的扩展</Description>
-		<PackageProjectUrl>https://github.com/serset/Vit.Library</PackageProjectUrl>
-	</PropertyGroup>
+    <PropertyGroup>
+        <Authors>Lith</Authors>
+        <Description>Linq extensions</Description>
+        <PackageProjectUrl>https://github.com/serset/Vit.Library</PackageProjectUrl>
+    </PropertyGroup>
 
-	<PropertyGroup>
-		<DocumentationFile>bin\Debug\netstandard2.0\Vit.Linq.xml</DocumentationFile>
-	</PropertyGroup>
+    <PropertyGroup>
+        <DocumentationFile>bin\Debug\netstandard2.0\Vit.Linq.xml</DocumentationFile>
+    </PropertyGroup>
 
-	<ItemGroup>
-		<PackageReference Include="Vit.Core" Version="2.1.19" />
-	</ItemGroup>
+    <ItemGroup>
+        <PackageReference Include="Vit.Core" Version="2.1.19" />
+    </ItemGroup>
 
-	<ItemGroup>
-	  <ProjectReference Include="..\Vit.Linq.QueryBuilder\Vit.Linq.QueryBuilder.csproj" />
-	</ItemGroup>
+    <ItemGroup>
+        <ProjectReference Include="..\Vit.Linq.QueryBuilder\Vit.Linq.QueryBuilder.csproj" />
+    </ItemGroup>
 
 </Project>