Synchronization code

Src/Asp.NetCore2/SqlSugar/Abstract/QueryableProvider/QueryMethodInfo.cs

@@ -0,0 +1,127 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+ 
+namespace SqlSugar 
+{
+    public class QueryMethodInfo
+    {
+        public object QueryableObj { get; internal set; }
+        public SqlSugarProvider Context { get; internal set; }
+
+        public QueryMethodInfo Where(string sql, object parameters)
+        {
+            var method = QueryableObj.GetType().GetMyMethod("Where", 2, typeof(string), typeof(object));
+            this.QueryableObj= method.Invoke(QueryableObj, new object[] { sql, parameters });
+            return this;
+        }
+     
+        public QueryMethodInfo SplitTable(Func<List<SplitTableInfo>, IEnumerable<SplitTableInfo>> getTableNamesFunc)
+        {
+            var method = QueryableObj.GetType().GetMyMethod("SplitTable", 1, typeof(Func<List<SplitTableInfo>, IEnumerable<SplitTableInfo>>));
+            this.QueryableObj = method.Invoke(QueryableObj, new object[] { getTableNamesFunc});
+            return this;
+        }
+        public QueryMethodInfo SplitTable(DateTime begintTime,DateTime endTime)
+        {
+            var method = QueryableObj.GetType().GetMyMethod("SplitTable", 2, typeof(DateTime), typeof(DateTime));
+            this.QueryableObj = method.Invoke(QueryableObj, new object[] {begintTime,endTime });
+            return this;
+        }
+        public QueryMethodInfo SplitTable()
+        {
+            var method = QueryableObj.GetType().GetMyMethod("SplitTable", 0);
+            this.QueryableObj = method.Invoke(QueryableObj, new object[] { });
+            return this;
+        }
+         
+        public QueryMethodInfo Select(string   selectorSql, Type   selectType)
+        {
+            var method = QueryableObj.GetType().GetMyMethod("Select", 1, typeof(string)) 
+             .MakeGenericMethod(selectType);
+            this.QueryableObj = method.Invoke(QueryableObj, new object[] { selectorSql });
+            return this;
+        }
+         
+        #region Result
+        public object ToPageList(int pageNumber, int pageSize)
+        {
+            var method = QueryableObj.GetType().GetMyMethod("ToPageList", 2, typeof(int), typeof(int));
+            var reslt = method.Invoke(QueryableObj, new object[] { pageNumber, pageSize });
+            return reslt;
+        }
+        public object ToPageList(int pageNumber, int pageSize, ref int count)
+        {
+            var method = QueryableObj.GetType().GetMyMethod("ToPageList", 3, typeof(int), typeof(int), typeof(int).MakeByRefType());
+            var parameters = new object[] { pageNumber, pageSize, count };
+            var reslt = method.Invoke(QueryableObj, parameters);
+            count = parameters.Last().ObjToInt();
+            return reslt;
+        }
+        public object ToList()
+        {
+            var method = QueryableObj.GetType().GetMyMethod("ToList", 0);
+            var reslt = method.Invoke(QueryableObj, new object[] { });
+            return reslt;
+        }
+        public object First()
+        {
+            var method = QueryableObj.GetType().GetMyMethod("First", 0);
+            var reslt = method.Invoke(QueryableObj, new object[] { });
+            return reslt;
+        }
+        public object Any()
+        {
+            var method = QueryableObj.GetType().GetMyMethod("Any", 0);
+            var reslt = method.Invoke(QueryableObj, new object[] { });
+            return reslt;
+        }
+        #endregion
+
+        #region Result Async
+        public async Task<object> ToPageListAsync(int pageNumber, int pageSize)
+        {
+            var method = QueryableObj.GetType().GetMyMethod("ToPageListAsync", 2, typeof(int), typeof(int));
+            Task task = (Task)method.Invoke(QueryableObj, new object[] { pageNumber, pageSize });
+            return await GetTask(task).ConfigureAwait(false);
+        }
+        public async Task<object> ToPageListAsync(int pageNumber, int pageSize, RefAsync<int> count)
+        {
+            var method = QueryableObj.GetType().GetMyMethod("ToPageListAsync", 3, typeof(int), typeof(int),typeof( RefAsync<int>));
+            var parameters = new object[] { pageNumber, pageSize, count };
+            var task = (Task)method.Invoke(QueryableObj, parameters);
+            return await GetTask(task).ConfigureAwait(false);
+        }
+        public async Task<object> ToListAsync()
+        {
+            var method = QueryableObj.GetType().GetMyMethod("ToListAsync", 0);
+            var task = (Task)method.Invoke(QueryableObj, new object[] { });
+            return await GetTask(task).ConfigureAwait(false);
+        }
+        public async Task<object> FirstAsync()
+        {
+            var method = QueryableObj.GetType().GetMyMethod("FirstAsync", 0);
+            var task = (Task)method.Invoke(QueryableObj, new object[] { });
+            return await GetTask(task).ConfigureAwait(false);
+        }
+        public async Task<bool> AnyAsync()
+        {
+            var method = QueryableObj.GetType().GetMyMethod("AnyAsync", 0);
+            var reslt = method.Invoke(QueryableObj, new object[] { });
+            return await (Task<bool>) reslt;
+        } 
+        #endregion
+
+        #region Helper
+        private static async Task<object> GetTask(Task task)
+        {
+            await task.ConfigureAwait(false); // 等待任务完成
+            var resultProperty = task.GetType().GetProperty("Result");
+            var result = resultProperty.GetValue(task);
+            return result;
+        }
+        #endregion
+    }
+}

Src/Asp.NetCore2/SqlSugar/Abstract/SugarProvider/SqlSugarProvider.cs

@@ -82,6 +82,16 @@ namespace SqlSugar
         #endregion
 
         #region Queryable
+        public QueryMethodInfo QueryableByObject(Type entityType) 
+        {
+            QueryMethodInfo result = new QueryMethodInfo();
+            var method=this.GetType().GetMyMethod("Queryable", 0);
+            var methodT=method.MakeGenericMethod(entityType);
+            var queryableObj=methodT.Invoke(this,new object[] {});
+            result.QueryableObj = queryableObj;
+            result.Context = this.Context;
+            return result;
+        }
         /// <summary>
         /// Get datebase time
         /// </summary>

Src/Asp.NetCore2/SqlSugar/Abstract/SugarProvider/SqlSugarScopeProvider.cs

@@ -815,6 +815,10 @@ namespace SqlSugar
         {
             ScopedContext.Tracking(datas);
         }
+        public QueryMethodInfo QueryableByObject(Type entityType)
+        {
+            return ScopedContext.QueryableByObject(entityType);
+        }
         #endregion
     }
 }

Src/Asp.NetCore2/SqlSugar/Interface/ISqlSugarClient.cs

@@ -79,6 +79,7 @@ namespace SqlSugar
         #endregion
 
         #region Queryable
+        QueryMethodInfo QueryableByObject(Type entityType);
         ISugarQueryable<T> MasterQueryable<T>();
         ISugarQueryable<T> SlaveQueryable<T>();
         ISugarQueryable<T> SqlQueryable<T>(string sql) where T : class, new();

Src/Asp.NetCore2/SqlSugar/SqlSugarClient.cs

@@ -284,6 +284,10 @@ namespace SqlSugar
         }
         #endregion
 
+        public QueryMethodInfo QueryableByObject(Type entityType) 
+        {
+            return this.Context.QueryableByObject(entityType);
+        }
         public ISugarQueryable<T> MasterQueryable<T>()
         {
             return this.Context.MasterQueryable<T>();

Src/Asp.NetCore2/SqlSugar/SqlSugarScope.cs

@@ -872,5 +872,9 @@ namespace SqlSugar
         {
             return ScopedContext.AsyncLock(timeOutSeconds);
         }
+        public QueryMethodInfo QueryableByObject(Type entityType)
+        {
+            return ScopedContext.QueryableByObject(entityType);
+        }
     }
 }

Src/Asp.NetCore2/SqlSugar/Utilities/CommonExtensions.cs

@@ -32,6 +32,21 @@ namespace SqlSugar
             it.GetParameters().Length == argCount&&
             it.GetParameters().First().ParameterType==parameterType);
         }
+        public static MethodInfo GetMyMethod(this Type type, string name, int argCount, Type parameterType,Type parameterType2)
+        {
+            return type.GetMethods().Where(it=>it.Name == name).FirstOrDefault(it =>
+            it.GetParameters().Length == argCount &&
+            it.GetParameters().First().ParameterType == parameterType&&
+            it.GetParameters()[1].ParameterType == parameterType2) ;
+        }
+        public static MethodInfo GetMyMethod(this Type type, string name, int argCount, Type parameterType, Type parameterType2, Type parameterType3)
+        {
+            return type.GetMethods().Where(it => it.Name == name).FirstOrDefault(it =>
+            it.GetParameters().Length == argCount &&
+            it.GetParameters().First().ParameterType == parameterType &&
+            it.GetParameters()[1].ParameterType == parameterType2&&
+            it.GetParameters()[2].ParameterType == parameterType3);
+        }
         public static List<T> ToList<T>(this  T thisValue,Func<T,T> action) where T:class,new()
         {
             return new List<T> { thisValue };