lsm/SqlSugar
1
0
Fork 0
mirror of https://gitee.com/dotnetchina/SqlSugar.git synced 2025-04-24 18:04:52 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update async

Browse Source
This commit is contained in:
sunkaixuan 2019-05-09 12:26:41 +08:00
parent c17f88f5c7
commit 87a0c5c8f3
5 changed files with 103 additions and 334 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
Src/Asp.Net/SqlSugar/Abstract/DeleteProvider/DeleteableProvider.cs
View File

@ -52,24 +52,12 @@ namespace SqlSugar
}
public Task<int> ExecuteCommandAsync()
{
Task<int> result = new Task<int>(() =>
{
IDeleteable<T> asyncDeleteable = CopyDeleteable();
return asyncDeleteable.ExecuteCommand();
});
TaskStart(result);
return result;
return Task.FromResult(ExecuteCommand());
}
public Task<bool> ExecuteCommandHasChangeAsync()
{
Task<bool> result = new Task<bool>(() =>
{
IDeleteable<T> asyncDeleteable = CopyDeleteable();
return asyncDeleteable.ExecuteCommand() > 0;
});
TaskStart(result);
return result;
return Task.FromResult(ExecuteCommandHasChange());
}
public IDeleteable<T> AS(string tableName)
{
@ -378,27 +366,6 @@ namespace SqlSugar
}
private IDeleteable<T> CopyDeleteable()
{
var asyncContext = this.Context.Utilities.CopyContext(true);
asyncContext.CurrentConnectionConfig.IsAutoCloseConnection = true;
asyncContext.IsAsyncMethod = true;
var asyncDeleteable = asyncContext.Deleteable<T>();
var asyncDeleteBuilder = asyncDeleteable.DeleteBuilder;
asyncDeleteBuilder.BigDataFiled = this.DeleteBuilder.BigDataFiled;
asyncDeleteBuilder.BigDataInValues = this.DeleteBuilder.BigDataInValues;
asyncDeleteBuilder.Parameters = this.DeleteBuilder.Parameters;
asyncDeleteBuilder.sql = this.DeleteBuilder.sql;
asyncDeleteBuilder.WhereInfos = this.DeleteBuilder.WhereInfos;
asyncDeleteBuilder.TableWithString = this.DeleteBuilder.TableWithString;
if (this.RemoveCacheFunc != null)
{
asyncDeleteable.RemoveDataCache();
}
return asyncDeleteable;
}
private void After(string sql)
{
if (this.IsEnableDiffLogEvent)

82
Src/Asp.Net/SqlSugar/Abstract/InsertableProvider/InsertableProvider.cs
View File

@ -133,53 +133,23 @@ namespace SqlSugar
}
public Task<int> ExecuteCommandAsync()
{
Task<int> result = new Task<int>(() =>
{
IInsertable<T> asyncInsertable = CopyInsertable();
return asyncInsertable.ExecuteCommand();
});
TaskStart(result);
return result;
return Task.FromResult(ExecuteCommand());
}
public Task<int> ExecuteReturnIdentityAsync()
{
Task<int> result = new Task<int>(() =>
{
IInsertable<T> asyncInsertable = CopyInsertable();
return asyncInsertable.ExecuteReturnIdentity();
});
TaskStart(result);
return result;
return Task.FromResult(ExecuteReturnIdentity());
}
public Task<T> ExecuteReturnEntityAsync()
{
Task<T> result = new Task<T>(() =>
{
IInsertable<T> asyncInsertable = CopyInsertable();
return asyncInsertable.ExecuteReturnEntity();
});
TaskStart(result);
return result;
return Task.FromResult(ExecuteReturnEntity());
}
public Task<bool> ExecuteCommandIdentityIntoEntityAsync()
{
Task<bool> result = new Task<bool>(() =>
{
IInsertable<T> asyncInsertable = CopyInsertable();
return asyncInsertable.ExecuteCommandIdentityIntoEntity();
});
TaskStart(result);
return result;
return Task.FromResult(ExecuteCommandIdentityIntoEntity());
}
public Task<long> ExecuteReturnBigIdentityAsync()
{
Task<long> result = new Task<long>(() =>
{
IInsertable<T> asyncInsertable = CopyInsertable();
return asyncInsertable.ExecuteReturnBigIdentity();
});
TaskStart(result);
return result;
return Task.FromResult(ExecuteReturnBigIdentity());
}
#endregion
@ -444,27 +414,27 @@ namespace SqlSugar
this.Context.MappingTables = OldMappingTableList;
}
}
protected IInsertable<T> CopyInsertable()
{
var asyncContext = this.Context.Utilities.CopyContext(true);
asyncContext.CurrentConnectionConfig.IsAutoCloseConnection = true;
asyncContext.IsAsyncMethod = true;
var asyncInsertable = asyncContext.Insertable<T>(this.InsertObjs);
var asyncInsertableBuilder = asyncInsertable.InsertBuilder;
asyncInsertableBuilder.DbColumnInfoList = this.InsertBuilder.DbColumnInfoList;
asyncInsertableBuilder.EntityInfo = this.InsertBuilder.EntityInfo;
asyncInsertableBuilder.Parameters = this.InsertBuilder.Parameters;
asyncInsertableBuilder.sql = this.InsertBuilder.sql;
asyncInsertableBuilder.IsNoInsertNull = this.InsertBuilder.IsNoInsertNull;
asyncInsertableBuilder.IsReturnIdentity = this.InsertBuilder.IsReturnIdentity;
asyncInsertableBuilder.EntityInfo = this.InsertBuilder.EntityInfo;
asyncInsertableBuilder.TableWithString = this.InsertBuilder.TableWithString;
if (this.RemoveCacheFunc != null)
{
asyncInsertable.RemoveDataCache();
}
return asyncInsertable;
}
//protected IInsertable<T> CopyInsertable()
//{
// var asyncContext = this.Context.Utilities.CopyContext(true);
// asyncContext.CurrentConnectionConfig.IsAutoCloseConnection = true;
// asyncContext.IsAsyncMethod = true;
// var asyncInsertable = asyncContext.Insertable<T>(this.InsertObjs);
// var asyncInsertableBuilder = asyncInsertable.InsertBuilder;
// asyncInsertableBuilder.DbColumnInfoList = this.InsertBuilder.DbColumnInfoList;
// asyncInsertableBuilder.EntityInfo = this.InsertBuilder.EntityInfo;
// asyncInsertableBuilder.Parameters = this.InsertBuilder.Parameters;
// asyncInsertableBuilder.sql = this.InsertBuilder.sql;
// asyncInsertableBuilder.IsNoInsertNull = this.InsertBuilder.IsNoInsertNull;
// asyncInsertableBuilder.IsReturnIdentity = this.InsertBuilder.IsReturnIdentity;
// asyncInsertableBuilder.EntityInfo = this.InsertBuilder.EntityInfo;
// asyncInsertableBuilder.TableWithString = this.InsertBuilder.TableWithString;
// if (this.RemoveCacheFunc != null)
// {
// asyncInsertable.RemoveDataCache();
// }
// return asyncInsertable;
//}
private void After(string sql, long? result)
{

244
Src/Asp.Net/SqlSugar/Abstract/QueryableProvider/QueryableProvider.cs
View File

@ -826,281 +826,125 @@ namespace SqlSugar
#region Async methods
public Task<T> SingleAsync()
{
Task<T> result = new Task<T>(() =>
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Single();
});
TaskStart(result);
return result;
return Task.FromResult(Single());
}
public Task<T> SingleAsync(Expression<Func<T, bool>> expression)
{
Task<T> result = new Task<T>(() =>
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Single(expression);
});
TaskStart(result);
return result;
return Task.FromResult(Single(expression));
}
public Task<T> FirstAsync()
{
Task<T> result = new Task<T>(() =>
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.First();
});
TaskStart(result);
return result;
return Task.FromResult(First());
}
public Task<T> FirstAsync(Expression<Func<T, bool>> expression)
{
Task<T> result = new Task<T>(() =>
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.First(expression);
});
TaskStart(result);
return result;
return Task.FromResult(First(expression));
}
public Task<bool> AnyAsync(Expression<Func<T, bool>> expression)
{
Task<bool> result = new Task<bool>(() =>
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Any(expression);
});
TaskStart(result);
return result;
return Task.FromResult(Any(expression));
}
public Task<bool> AnyAsync()
{
Task<bool> result = new Task<bool>(() =>
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Any();
});
TaskStart(result);
return result;
return Task.FromResult(Any());
}
public Task<int> CountAsync()
{
Task<int> result = new Task<int>(() =>
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Count();
});
TaskStart(result);
return result;
return Task.FromResult(Count());
}
public Task<int> CountAsync(Expression<Func<T, bool>> expression)
{
Task<int> result = new Task<int>(() =>
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Count(expression);
});
TaskStart(result); ;
return result;
return Task.FromResult(Count(expression));
}
public Task<TResult> MaxAsync<TResult>(string maxField)
{
Task<TResult> result = new Task<TResult>(() =>
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Max<TResult>(maxField);
});
TaskStart(result);
return result;
return Task.FromResult(Max<TResult>(maxField));
}
public Task<TResult> MaxAsync<TResult>(Expression<Func<T, TResult>> expression)
{
Task<TResult> result = new Task<TResult>(() =>
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Max<TResult>(expression);
});
TaskStart(result);
return result;
return Task.FromResult(Max<TResult>(expression));
}
public Task<TResult> MinAsync<TResult>(string minField)
{
Task<TResult> result = new Task<TResult>(() =>
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Min<TResult>(minField);
});
TaskStart(result);
return result;
return Task.FromResult(Min<TResult>(minField));
}
public Task<TResult> MinAsync<TResult>(Expression<Func<T, TResult>> expression)
{
Task<TResult> result = new Task<TResult>(() =>
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Min<TResult>(expression);
});
TaskStart(result);
return result;
return Task.FromResult(Min<TResult>(expression));
}
public Task<TResult> SumAsync<TResult>(string sumField)
{
Task<TResult> result = new Task<TResult>(() =>
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Sum<TResult>(sumField);
});
TaskStart(result);
return result;
return Task.FromResult(Sum<TResult>(sumField));
}
public Task<TResult> SumAsync<TResult>(Expression<Func<T, TResult>> expression)
{
Task<TResult> result = new Task<TResult>(() =>
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Sum<TResult>(expression);
});
TaskStart(result);
return result;
return Task.FromResult(Sum<TResult>(expression));
}
public Task<TResult> AvgAsync<TResult>(string avgField)
{
Task<TResult> result = new Task<TResult>(() =>
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Avg<TResult>(avgField);
});
TaskStart(result);
return result;
return Task.FromResult(Avg<TResult>(avgField));
}
public Task<TResult> AvgAsync<TResult>(Expression<Func<T, TResult>> expression)
{
Task<TResult> result = new Task<TResult>(() =>
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Avg<TResult>(expression);
});
TaskStart(result);
return result;
return Task.FromResult(Avg<TResult>(expression));
}
public Task<List<T>> ToListAsync()
{
Task<List<T>> result = new Task<List<T>>(() =>
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.ToList();
});
TaskStart(result);
return result;
return Task.FromResult(ToList());
}
public Task<string> ToJsonAsync()
{
Task<string> result = new Task<string>(() =>
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.ToJson();
});
TaskStart(result);
return result;
return Task.FromResult(ToJson());
}
public Task<string> ToJsonPageAsync(int pageIndex, int pageSize)
{
Task<string> result = new Task<string>(() =>
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.ToJsonPage(pageIndex, pageSize);
});
TaskStart(result);
return result;
return Task.FromResult(ToJsonPage(pageIndex,pageSize));
}
public Task<KeyValuePair<string, int>> ToJsonPageAsync(int pageIndex, int pageSize, int totalNumber)
public Task<string> ToJsonPageAsync(int pageIndex, int pageSize,ref int totalNumber)
{
Task<KeyValuePair<string, int>> result = new Task<KeyValuePair<string, int>>(() =>
{
int totalNumberAsync = 0;
ISugarQueryable<T> asyncQueryable = CopyQueryable();
var list = asyncQueryable.ToJsonPage(pageIndex, pageSize, ref totalNumberAsync);
return new KeyValuePair<string, int>(list, totalNumberAsync);
});
TaskStart(result);
return result;
return Task.FromResult(ToJsonPage(pageIndex, pageSize,ref totalNumber));
}
public Task<DataTable> ToDataTableAsync()
{
Task<DataTable> result = new Task<DataTable>(() =>
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.ToDataTable();
});
TaskStart(result);
return result;
return Task.FromResult(ToDataTable());
}
public Task<DataTable> ToDataTablePageAsync(int pageIndex, int pageSize)
{
Task<DataTable> result = new Task<DataTable>(() =>
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.ToDataTablePage(pageIndex, pageSize);
});
TaskStart(result);
return result;
return Task.FromResult(ToDataTablePage(pageIndex,pageSize));
}
public Task<KeyValuePair<DataTable, int>> ToDataTablePageAsync(int pageIndex, int pageSize, int totalNumber)
public Task<DataTable> ToDataTablePageAsync(int pageIndex, int pageSize,ref int totalNumber)
{
Task<KeyValuePair<DataTable, int>> result = new Task<KeyValuePair<DataTable, int>>(() =>
{
int totalNumberAsync = 0;
ISugarQueryable<T> asyncQueryable = CopyQueryable();
var list = asyncQueryable.ToDataTablePage(pageIndex, pageSize, ref totalNumberAsync);
return new KeyValuePair<DataTable, int>(list, totalNumberAsync);
});
TaskStart(result);
return result;
return Task.FromResult(ToDataTablePage(pageIndex, pageSize,ref totalNumber));
}
public Task<List<T>> ToPageListAsync(int pageIndex, int pageSize)
{
Task<List<T>> result = new Task<List<T>>(() =>
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.ToPageList(pageIndex, pageSize);
});
TaskStart(result);
return result;
return Task.FromResult(ToPageList(pageIndex,pageSize));
}
public Task<KeyValuePair<List<T>, int>> ToPageListAsync(int pageIndex, int pageSize, int totalNumber)
public Task<List<T>> ToPageListAsync(int pageIndex, int pageSize, ref int totalNumber)
{
Task<KeyValuePair<List<T>, int>> result = new Task<KeyValuePair<List<T>, int>>(() =>
{
int totalNumberAsync = 0;
ISugarQueryable<T> asyncQueryable = CopyQueryable();
var list = asyncQueryable.ToPageList(pageIndex, pageSize, ref totalNumberAsync);
return new KeyValuePair<List<T>, int>(list, totalNumberAsync);
});
TaskStart(result);
return result;
return Task.FromResult(ToPageList(pageIndex, pageSize,ref totalNumber));
}
#endregion
@ -1605,22 +1449,22 @@ namespace SqlSugar
}
}
}
protected ISugarQueryable<T> CopyQueryable()
{
var asyncContext = this.Context.Utilities.CopyContext(true);
asyncContext.IsAsyncMethod = true;
asyncContext.CurrentConnectionConfig.IsAutoCloseConnection = true;
var asyncQueryable = asyncContext.Queryable<ExpandoObject>().Select<T>(string.Empty).WithCacheIF(IsCache, CacheTime);
if (this.MapperAction != null)
asyncQueryable.Mapper(MapperAction);
if (this.MapperActionWithCache != null)
asyncQueryable.Mapper(MapperActionWithCache);
if (this.Mappers != null && ((asyncQueryable as QueryableProvider<T>)!=null))
{
(asyncQueryable as QueryableProvider<T>).Mappers = this.Mappers;
}
CopyQueryBuilder(asyncQueryable.QueryBuilder); return asyncQueryable;
}
//protected ISugarQueryable<T> CopyQueryable()
//{
// var asyncContext = this.Context.Utilities.CopyContext(true);
// asyncContext.IsAsyncMethod = true;
// asyncContext.CurrentConnectionConfig.IsAutoCloseConnection = true;
// var asyncQueryable = asyncContext.Queryable<ExpandoObject>().Select<T>(string.Empty).WithCacheIF(IsCache, CacheTime);
// if (this.MapperAction != null)
// asyncQueryable.Mapper(MapperAction);
// if (this.MapperActionWithCache != null)
// asyncQueryable.Mapper(MapperActionWithCache);
// if (this.Mappers != null && ((asyncQueryable as QueryableProvider<T>)!=null))
// {
// (asyncQueryable as QueryableProvider<T>).Mappers = this.Mappers;
// }
// CopyQueryBuilder(asyncQueryable.QueryBuilder); return asyncQueryable;
//}
protected void CopyQueryBuilder(QueryBuilder asyncQueryableBuilder)
{

72
Src/Asp.Net/SqlSugar/Abstract/UpdateProvider/UpdateableProvider.cs
View File

@ -69,23 +69,11 @@ namespace SqlSugar
}
public Task<int> ExecuteCommandAsync()
{
Task<int> result = new Task<int>(() =>
{
IUpdateable<T> asyncUpdateable = CopyUpdateable();
return asyncUpdateable.ExecuteCommand();
});
TaskStart(result);
return result;
return Task.FromResult(ExecuteCommand());
}
public Task<bool> ExecuteCommandHasChangeAsync()
{
Task<bool> result = new Task<bool>(() =>
{
IUpdateable<T> asyncUpdateable = CopyUpdateable();
return asyncUpdateable.ExecuteCommand() > 0;
});
TaskStart(result);
return result;
return Task.FromResult(ExecuteCommandHasChange());
}
#endregion
@ -602,35 +590,35 @@ namespace SqlSugar
}
result.Start();
}
private IUpdateable<T> CopyUpdateable()
{
var asyncContext = this.Context.Utilities.CopyContext(true);
asyncContext.CurrentConnectionConfig.IsAutoCloseConnection = true;
asyncContext.IsAsyncMethod = true;
//private IUpdateable<T> CopyUpdateable()
//{
// var asyncContext = this.Context.Utilities.CopyContext(true);
// asyncContext.CurrentConnectionConfig.IsAutoCloseConnection = true;
// asyncContext.IsAsyncMethod = true;
var asyncUpdateable = asyncContext.Updateable<T>(this.UpdateObjs);
var asyncUpdateableBuilder = asyncUpdateable.UpdateBuilder;
asyncUpdateableBuilder.DbColumnInfoList = this.UpdateBuilder.DbColumnInfoList;
asyncUpdateableBuilder.IsNoUpdateNull = this.UpdateBuilder.IsNoUpdateNull;
asyncUpdateableBuilder.Parameters = this.UpdateBuilder.Parameters;
asyncUpdateableBuilder.sql = this.UpdateBuilder.sql;
asyncUpdateableBuilder.WhereValues = this.UpdateBuilder.WhereValues;
asyncUpdateableBuilder.TableWithString = this.UpdateBuilder.TableWithString;
asyncUpdateableBuilder.TableName = this.UpdateBuilder.TableName;
asyncUpdateableBuilder.PrimaryKeys = this.UpdateBuilder.PrimaryKeys;
asyncUpdateableBuilder.IsOffIdentity = this.UpdateBuilder.IsOffIdentity;
asyncUpdateableBuilder.SetValues = this.UpdateBuilder.SetValues;
if (this.IsWhereColumns)
{
(asyncUpdateable as UpdateableProvider<T>).WhereColumnList = this.WhereColumnList;
(asyncUpdateable as UpdateableProvider<T>).IsWhereColumns = this.IsWhereColumns;
}
if (this.RemoveCacheFunc != null)
{
asyncUpdateable.RemoveDataCache();
}
return asyncUpdateable;
}
// var asyncUpdateable = asyncContext.Updateable<T>(this.UpdateObjs);
// var asyncUpdateableBuilder = asyncUpdateable.UpdateBuilder;
// asyncUpdateableBuilder.DbColumnInfoList = this.UpdateBuilder.DbColumnInfoList;
// asyncUpdateableBuilder.IsNoUpdateNull = this.UpdateBuilder.IsNoUpdateNull;
// asyncUpdateableBuilder.Parameters = this.UpdateBuilder.Parameters;
// asyncUpdateableBuilder.sql = this.UpdateBuilder.sql;
// asyncUpdateableBuilder.WhereValues = this.UpdateBuilder.WhereValues;
// asyncUpdateableBuilder.TableWithString = this.UpdateBuilder.TableWithString;
// asyncUpdateableBuilder.TableName = this.UpdateBuilder.TableName;
// asyncUpdateableBuilder.PrimaryKeys = this.UpdateBuilder.PrimaryKeys;
// asyncUpdateableBuilder.IsOffIdentity = this.UpdateBuilder.IsOffIdentity;
// asyncUpdateableBuilder.SetValues = this.UpdateBuilder.SetValues;
// if (this.IsWhereColumns)
// {
// (asyncUpdateable as UpdateableProvider<T>).WhereColumnList = this.WhereColumnList;
// (asyncUpdateable as UpdateableProvider<T>).IsWhereColumns = this.IsWhereColumns;
// }
// if (this.RemoveCacheFunc != null)
// {
// asyncUpdateable.RemoveDataCache();
// }
// return asyncUpdateable;
//}
private void ValidateVersion()
{

2
Src/Asp.Net/SqlSugar/SqlSugar.csproj
View File

@ -9,7 +9,7 @@
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>SqlSugar</RootNamespace>
<AssemblyName>SqlSugar</AssemblyName>
<TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<TargetFrameworkProfile />
</PropertyGroup>