lsm/SqlSugar
1
0
Fork 0
mirror of https://gitee.com/dotnetchina/SqlSugar.git synced 2025-05-09 07:07:59 +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() public Task<int> ExecuteCommandAsync()
{ {
Task<int> result = new Task<int>(() => return Task.FromResult(ExecuteCommand());
{
IDeleteable<T> asyncDeleteable = CopyDeleteable();
return asyncDeleteable.ExecuteCommand();
});
TaskStart(result);
return result;
} }
public Task<bool> ExecuteCommandHasChangeAsync() public Task<bool> ExecuteCommandHasChangeAsync()
{ {
Task<bool> result = new Task<bool>(() => return Task.FromResult(ExecuteCommandHasChange());
{
IDeleteable<T> asyncDeleteable = CopyDeleteable();
return asyncDeleteable.ExecuteCommand() > 0;
});
TaskStart(result);
return result;
} }
public IDeleteable<T> AS(string tableName) 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) private void After(string sql)
{ {
if (this.IsEnableDiffLogEvent) if (this.IsEnableDiffLogEvent)

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

@ -133,53 +133,23 @@ namespace SqlSugar
} }
public Task<int> ExecuteCommandAsync() public Task<int> ExecuteCommandAsync()
{ {
Task<int> result = new Task<int>(() => return Task.FromResult(ExecuteCommand());
{
IInsertable<T> asyncInsertable = CopyInsertable();
return asyncInsertable.ExecuteCommand();
});
TaskStart(result);
return result;
} }
public Task<int> ExecuteReturnIdentityAsync() public Task<int> ExecuteReturnIdentityAsync()
{ {
Task<int> result = new Task<int>(() => return Task.FromResult(ExecuteReturnIdentity());
{
IInsertable<T> asyncInsertable = CopyInsertable();
return asyncInsertable.ExecuteReturnIdentity();
});
TaskStart(result);
return result;
} }
public Task<T> ExecuteReturnEntityAsync() public Task<T> ExecuteReturnEntityAsync()
{ {
Task<T> result = new Task<T>(() => return Task.FromResult(ExecuteReturnEntity());
{
IInsertable<T> asyncInsertable = CopyInsertable();
return asyncInsertable.ExecuteReturnEntity();
});
TaskStart(result);
return result;
} }
public Task<bool> ExecuteCommandIdentityIntoEntityAsync() public Task<bool> ExecuteCommandIdentityIntoEntityAsync()
{ {
Task<bool> result = new Task<bool>(() => return Task.FromResult(ExecuteCommandIdentityIntoEntity());
{
IInsertable<T> asyncInsertable = CopyInsertable();
return asyncInsertable.ExecuteCommandIdentityIntoEntity();
});
TaskStart(result);
return result;
} }
public Task<long> ExecuteReturnBigIdentityAsync() public Task<long> ExecuteReturnBigIdentityAsync()
{ {
Task<long> result = new Task<long>(() => return Task.FromResult(ExecuteReturnBigIdentity());
{
IInsertable<T> asyncInsertable = CopyInsertable();
return asyncInsertable.ExecuteReturnBigIdentity();
});
TaskStart(result);
return result;
} }
#endregion #endregion
@ -444,27 +414,27 @@ namespace SqlSugar
this.Context.MappingTables = OldMappingTableList; this.Context.MappingTables = OldMappingTableList;
} }
} }
protected IInsertable<T> CopyInsertable() //protected IInsertable<T> CopyInsertable()
{ //{
var asyncContext = this.Context.Utilities.CopyContext(true); // var asyncContext = this.Context.Utilities.CopyContext(true);
asyncContext.CurrentConnectionConfig.IsAutoCloseConnection = true; // asyncContext.CurrentConnectionConfig.IsAutoCloseConnection = true;
asyncContext.IsAsyncMethod = true; // asyncContext.IsAsyncMethod = true;
var asyncInsertable = asyncContext.Insertable<T>(this.InsertObjs); // var asyncInsertable = asyncContext.Insertable<T>(this.InsertObjs);
var asyncInsertableBuilder = asyncInsertable.InsertBuilder; // var asyncInsertableBuilder = asyncInsertable.InsertBuilder;
asyncInsertableBuilder.DbColumnInfoList = this.InsertBuilder.DbColumnInfoList; // asyncInsertableBuilder.DbColumnInfoList = this.InsertBuilder.DbColumnInfoList;
asyncInsertableBuilder.EntityInfo = this.InsertBuilder.EntityInfo; // asyncInsertableBuilder.EntityInfo = this.InsertBuilder.EntityInfo;
asyncInsertableBuilder.Parameters = this.InsertBuilder.Parameters; // asyncInsertableBuilder.Parameters = this.InsertBuilder.Parameters;
asyncInsertableBuilder.sql = this.InsertBuilder.sql; // asyncInsertableBuilder.sql = this.InsertBuilder.sql;
asyncInsertableBuilder.IsNoInsertNull = this.InsertBuilder.IsNoInsertNull; // asyncInsertableBuilder.IsNoInsertNull = this.InsertBuilder.IsNoInsertNull;
asyncInsertableBuilder.IsReturnIdentity = this.InsertBuilder.IsReturnIdentity; // asyncInsertableBuilder.IsReturnIdentity = this.InsertBuilder.IsReturnIdentity;
asyncInsertableBuilder.EntityInfo = this.InsertBuilder.EntityInfo; // asyncInsertableBuilder.EntityInfo = this.InsertBuilder.EntityInfo;
asyncInsertableBuilder.TableWithString = this.InsertBuilder.TableWithString; // asyncInsertableBuilder.TableWithString = this.InsertBuilder.TableWithString;
if (this.RemoveCacheFunc != null) // if (this.RemoveCacheFunc != null)
{ // {
asyncInsertable.RemoveDataCache(); // asyncInsertable.RemoveDataCache();
} // }
return asyncInsertable; // return asyncInsertable;
} //}
private void After(string sql, long? result) 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 #region Async methods
public Task<T> SingleAsync() public Task<T> SingleAsync()
{ {
Task<T> result = new Task<T>(() => return Task.FromResult(Single());
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Single();
});
TaskStart(result);
return result;
} }
public Task<T> SingleAsync(Expression<Func<T, bool>> expression) public Task<T> SingleAsync(Expression<Func<T, bool>> expression)
{ {
Task<T> result = new Task<T>(() => return Task.FromResult(Single(expression));
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Single(expression);
});
TaskStart(result);
return result;
} }
public Task<T> FirstAsync() public Task<T> FirstAsync()
{ {
Task<T> result = new Task<T>(() => return Task.FromResult(First());
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.First();
});
TaskStart(result);
return result;
} }
public Task<T> FirstAsync(Expression<Func<T, bool>> expression) public Task<T> FirstAsync(Expression<Func<T, bool>> expression)
{ {
Task<T> result = new Task<T>(() => return Task.FromResult(First(expression));
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.First(expression);
});
TaskStart(result);
return result;
} }
public Task<bool> AnyAsync(Expression<Func<T, bool>> expression) public Task<bool> AnyAsync(Expression<Func<T, bool>> expression)
{ {
Task<bool> result = new Task<bool>(() => return Task.FromResult(Any(expression));
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Any(expression);
});
TaskStart(result);
return result;
} }
public Task<bool> AnyAsync() public Task<bool> AnyAsync()
{ {
Task<bool> result = new Task<bool>(() => return Task.FromResult(Any());
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Any();
});
TaskStart(result);
return result;
} }
public Task<int> CountAsync() public Task<int> CountAsync()
{ {
Task<int> result = new Task<int>(() => return Task.FromResult(Count());
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Count();
});
TaskStart(result);
return result;
} }
public Task<int> CountAsync(Expression<Func<T, bool>> expression) public Task<int> CountAsync(Expression<Func<T, bool>> expression)
{ {
Task<int> result = new Task<int>(() => return Task.FromResult(Count(expression));
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Count(expression);
});
TaskStart(result); ;
return result;
} }
public Task<TResult> MaxAsync<TResult>(string maxField) public Task<TResult> MaxAsync<TResult>(string maxField)
{ {
Task<TResult> result = new Task<TResult>(() => return Task.FromResult(Max<TResult>(maxField));
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Max<TResult>(maxField);
});
TaskStart(result);
return result;
} }
public Task<TResult> MaxAsync<TResult>(Expression<Func<T, TResult>> expression) public Task<TResult> MaxAsync<TResult>(Expression<Func<T, TResult>> expression)
{ {
Task<TResult> result = new Task<TResult>(() => return Task.FromResult(Max<TResult>(expression));
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Max<TResult>(expression);
});
TaskStart(result);
return result;
} }
public Task<TResult> MinAsync<TResult>(string minField) public Task<TResult> MinAsync<TResult>(string minField)
{ {
Task<TResult> result = new Task<TResult>(() => return Task.FromResult(Min<TResult>(minField));
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Min<TResult>(minField);
});
TaskStart(result);
return result;
} }
public Task<TResult> MinAsync<TResult>(Expression<Func<T, TResult>> expression) public Task<TResult> MinAsync<TResult>(Expression<Func<T, TResult>> expression)
{ {
Task<TResult> result = new Task<TResult>(() => return Task.FromResult(Min<TResult>(expression));
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Min<TResult>(expression);
});
TaskStart(result);
return result;
} }
public Task<TResult> SumAsync<TResult>(string sumField) public Task<TResult> SumAsync<TResult>(string sumField)
{ {
Task<TResult> result = new Task<TResult>(() => return Task.FromResult(Sum<TResult>(sumField));
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Sum<TResult>(sumField);
});
TaskStart(result);
return result;
} }
public Task<TResult> SumAsync<TResult>(Expression<Func<T, TResult>> expression) public Task<TResult> SumAsync<TResult>(Expression<Func<T, TResult>> expression)
{ {
Task<TResult> result = new Task<TResult>(() => return Task.FromResult(Sum<TResult>(expression));
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Sum<TResult>(expression);
});
TaskStart(result);
return result;
} }
public Task<TResult> AvgAsync<TResult>(string avgField) public Task<TResult> AvgAsync<TResult>(string avgField)
{ {
Task<TResult> result = new Task<TResult>(() => return Task.FromResult(Avg<TResult>(avgField));
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Avg<TResult>(avgField);
});
TaskStart(result);
return result;
} }
public Task<TResult> AvgAsync<TResult>(Expression<Func<T, TResult>> expression) public Task<TResult> AvgAsync<TResult>(Expression<Func<T, TResult>> expression)
{ {
Task<TResult> result = new Task<TResult>(() => return Task.FromResult(Avg<TResult>(expression));
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.Avg<TResult>(expression);
});
TaskStart(result);
return result;
} }
public Task<List<T>> ToListAsync() public Task<List<T>> ToListAsync()
{ {
Task<List<T>> result = new Task<List<T>>(() => return Task.FromResult(ToList());
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.ToList();
});
TaskStart(result);
return result;
} }
public Task<string> ToJsonAsync() public Task<string> ToJsonAsync()
{ {
Task<string> result = new Task<string>(() => return Task.FromResult(ToJson());
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.ToJson();
});
TaskStart(result);
return result;
} }
public Task<string> ToJsonPageAsync(int pageIndex, int pageSize) public Task<string> ToJsonPageAsync(int pageIndex, int pageSize)
{ {
Task<string> result = new Task<string>(() => return Task.FromResult(ToJsonPage(pageIndex,pageSize));
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.ToJsonPage(pageIndex, pageSize);
});
TaskStart(result);
return result;
} }
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>>(() => return Task.FromResult(ToJsonPage(pageIndex, pageSize,ref totalNumber));
{
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;
} }
public Task<DataTable> ToDataTableAsync() public Task<DataTable> ToDataTableAsync()
{ {
Task<DataTable> result = new Task<DataTable>(() => return Task.FromResult(ToDataTable());
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.ToDataTable();
});
TaskStart(result);
return result;
} }
public Task<DataTable> ToDataTablePageAsync(int pageIndex, int pageSize) public Task<DataTable> ToDataTablePageAsync(int pageIndex, int pageSize)
{ {
Task<DataTable> result = new Task<DataTable>(() => return Task.FromResult(ToDataTablePage(pageIndex,pageSize));
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.ToDataTablePage(pageIndex, pageSize);
});
TaskStart(result);
return result;
} }
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>>(() => return Task.FromResult(ToDataTablePage(pageIndex, pageSize,ref totalNumber));
{
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;
} }
public Task<List<T>> ToPageListAsync(int pageIndex, int pageSize) public Task<List<T>> ToPageListAsync(int pageIndex, int pageSize)
{ {
Task<List<T>> result = new Task<List<T>>(() => return Task.FromResult(ToPageList(pageIndex,pageSize));
{
ISugarQueryable<T> asyncQueryable = CopyQueryable();
return asyncQueryable.ToPageList(pageIndex, pageSize);
});
TaskStart(result);
return result;
} }
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>>(() => return Task.FromResult(ToPageList(pageIndex, pageSize,ref totalNumber));
{
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;
} }
#endregion #endregion
@ -1605,22 +1449,22 @@ namespace SqlSugar
} }
} }
} }
protected ISugarQueryable<T> CopyQueryable() //protected ISugarQueryable<T> CopyQueryable()
{ //{
var asyncContext = this.Context.Utilities.CopyContext(true); // var asyncContext = this.Context.Utilities.CopyContext(true);
asyncContext.IsAsyncMethod = true; // asyncContext.IsAsyncMethod = true;
asyncContext.CurrentConnectionConfig.IsAutoCloseConnection = true; // asyncContext.CurrentConnectionConfig.IsAutoCloseConnection = true;
var asyncQueryable = asyncContext.Queryable<ExpandoObject>().Select<T>(string.Empty).WithCacheIF(IsCache, CacheTime); // var asyncQueryable = asyncContext.Queryable<ExpandoObject>().Select<T>(string.Empty).WithCacheIF(IsCache, CacheTime);
if (this.MapperAction != null) // if (this.MapperAction != null)
asyncQueryable.Mapper(MapperAction); // asyncQueryable.Mapper(MapperAction);
if (this.MapperActionWithCache != null) // if (this.MapperActionWithCache != null)
asyncQueryable.Mapper(MapperActionWithCache); // asyncQueryable.Mapper(MapperActionWithCache);
if (this.Mappers != null && ((asyncQueryable as QueryableProvider<T>)!=null)) // if (this.Mappers != null && ((asyncQueryable as QueryableProvider<T>)!=null))
{ // {
(asyncQueryable as QueryableProvider<T>).Mappers = this.Mappers; // (asyncQueryable as QueryableProvider<T>).Mappers = this.Mappers;
} // }
CopyQueryBuilder(asyncQueryable.QueryBuilder); return asyncQueryable; // CopyQueryBuilder(asyncQueryable.QueryBuilder); return asyncQueryable;
} //}
protected void CopyQueryBuilder(QueryBuilder asyncQueryableBuilder) 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() public Task<int> ExecuteCommandAsync()
{ {
Task<int> result = new Task<int>(() => return Task.FromResult(ExecuteCommand());
{
IUpdateable<T> asyncUpdateable = CopyUpdateable();
return asyncUpdateable.ExecuteCommand();
});
TaskStart(result);
return result;
} }
public Task<bool> ExecuteCommandHasChangeAsync() public Task<bool> ExecuteCommandHasChangeAsync()
{ {
Task<bool> result = new Task<bool>(() => return Task.FromResult(ExecuteCommandHasChange());
{
IUpdateable<T> asyncUpdateable = CopyUpdateable();
return asyncUpdateable.ExecuteCommand() > 0;
});
TaskStart(result);
return result;
} }
#endregion #endregion
@ -602,35 +590,35 @@ namespace SqlSugar
} }
result.Start(); result.Start();
} }
private IUpdateable<T> CopyUpdateable() //private IUpdateable<T> CopyUpdateable()
{ //{
var asyncContext = this.Context.Utilities.CopyContext(true); // var asyncContext = this.Context.Utilities.CopyContext(true);
asyncContext.CurrentConnectionConfig.IsAutoCloseConnection = true; // asyncContext.CurrentConnectionConfig.IsAutoCloseConnection = true;
asyncContext.IsAsyncMethod = true; // asyncContext.IsAsyncMethod = true;
var asyncUpdateable = asyncContext.Updateable<T>(this.UpdateObjs); // var asyncUpdateable = asyncContext.Updateable<T>(this.UpdateObjs);
var asyncUpdateableBuilder = asyncUpdateable.UpdateBuilder; // var asyncUpdateableBuilder = asyncUpdateable.UpdateBuilder;
asyncUpdateableBuilder.DbColumnInfoList = this.UpdateBuilder.DbColumnInfoList; // asyncUpdateableBuilder.DbColumnInfoList = this.UpdateBuilder.DbColumnInfoList;
asyncUpdateableBuilder.IsNoUpdateNull = this.UpdateBuilder.IsNoUpdateNull; // asyncUpdateableBuilder.IsNoUpdateNull = this.UpdateBuilder.IsNoUpdateNull;
asyncUpdateableBuilder.Parameters = this.UpdateBuilder.Parameters; // asyncUpdateableBuilder.Parameters = this.UpdateBuilder.Parameters;
asyncUpdateableBuilder.sql = this.UpdateBuilder.sql; // asyncUpdateableBuilder.sql = this.UpdateBuilder.sql;
asyncUpdateableBuilder.WhereValues = this.UpdateBuilder.WhereValues; // asyncUpdateableBuilder.WhereValues = this.UpdateBuilder.WhereValues;
asyncUpdateableBuilder.TableWithString = this.UpdateBuilder.TableWithString; // asyncUpdateableBuilder.TableWithString = this.UpdateBuilder.TableWithString;
asyncUpdateableBuilder.TableName = this.UpdateBuilder.TableName; // asyncUpdateableBuilder.TableName = this.UpdateBuilder.TableName;
asyncUpdateableBuilder.PrimaryKeys = this.UpdateBuilder.PrimaryKeys; // asyncUpdateableBuilder.PrimaryKeys = this.UpdateBuilder.PrimaryKeys;
asyncUpdateableBuilder.IsOffIdentity = this.UpdateBuilder.IsOffIdentity; // asyncUpdateableBuilder.IsOffIdentity = this.UpdateBuilder.IsOffIdentity;
asyncUpdateableBuilder.SetValues = this.UpdateBuilder.SetValues; // asyncUpdateableBuilder.SetValues = this.UpdateBuilder.SetValues;
if (this.IsWhereColumns) // if (this.IsWhereColumns)
{ // {
(asyncUpdateable as UpdateableProvider<T>).WhereColumnList = this.WhereColumnList; // (asyncUpdateable as UpdateableProvider<T>).WhereColumnList = this.WhereColumnList;
(asyncUpdateable as UpdateableProvider<T>).IsWhereColumns = this.IsWhereColumns; // (asyncUpdateable as UpdateableProvider<T>).IsWhereColumns = this.IsWhereColumns;
} // }
if (this.RemoveCacheFunc != null) // if (this.RemoveCacheFunc != null)
{ // {
asyncUpdateable.RemoveDataCache(); // asyncUpdateable.RemoveDataCache();
} // }
return asyncUpdateable; // return asyncUpdateable;
} //}
private void ValidateVersion() private void ValidateVersion()
{ {

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

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