diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSeverTest/Demo/Demo1_Queryable.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSeverTest/Demo/Demo1_Queryable.cs index ccabe261f..6be3a9815 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSeverTest/Demo/Demo1_Queryable.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSeverTest/Demo/Demo1_Queryable.cs @@ -197,9 +197,8 @@ namespace OrmTest SqlSugarClient db = GetInstance(); var task1 = db.Queryable().FirstAsync(); - var task2 = db.Queryable().Where(it => it.Id == 1).ToListAsync(); - task1.Wait(); + var task2 = db.Queryable().Where(it => it.Id == 1).ToListAsync(); task2.Wait(); Console.WriteLine("#### Async End ####"); diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/AdoProvider/AdoProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/AdoProvider/AdoProvider.cs index e1fbdf58f..ff8c04e8c 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/AdoProvider/AdoProvider.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/AdoProvider/AdoProvider.cs @@ -60,12 +60,12 @@ namespace SqlSugar public virtual CommandType CommandType { get; set; } public virtual bool IsEnableLogEvent { get; set; } public virtual bool IsClearParameters { get; set; } - public virtual Action LogEventStarting => this.Context.CurrentConnectionConfig.AopEvents.OnLogExecuting; - public virtual Action LogEventCompleted => this.Context.CurrentConnectionConfig.AopEvents.OnLogExecuted; - public virtual Func> ProcessingEventStartingSQL => this.Context.CurrentConnectionConfig.AopEvents.OnExecutingChangeSql; + public virtual Action LogEventStarting => this.Context.CurrentConnectionConfig.AopEvents?.OnLogExecuting; + public virtual Action LogEventCompleted => this.Context.CurrentConnectionConfig.AopEvents?.OnLogExecuted; + public virtual Func> ProcessingEventStartingSQL => this.Context.CurrentConnectionConfig.AopEvents?.OnExecutingChangeSql; protected virtual Func FormatSql { get; set; } - public virtual Action ErrorEvent => this.Context.CurrentConnectionConfig.AopEvents.OnError; - public virtual Action DiffLogEvent => this.Context.CurrentConnectionConfig.AopEvents.OnDiffLogEvent; + public virtual Action ErrorEvent => this.Context.CurrentConnectionConfig.AopEvents?.OnError; + public virtual Action DiffLogEvent => this.Context.CurrentConnectionConfig.AopEvents?.OnDiffLogEvent; public virtual List SlaveConnections { get; set; } public virtual IDbConnection MasterConnection { get; set; } #endregion @@ -248,32 +248,6 @@ namespace SqlSugar return Task.FromResult(UseTran(action, errorCallBack)); } - public void UseStoredProcedure(Action action) - { - var oldCommandType = this.CommandType; - this.CommandType = CommandType.StoredProcedure; - this.IsClearParameters = false; - if (action != null) - { - action(); - } - this.CommandType = oldCommandType; - this.IsClearParameters = true; - } - public T UseStoredProcedure(Func action) - { - T result = default(T); - var oldCommandType = this.CommandType; - this.CommandType = CommandType.StoredProcedure; - this.IsClearParameters = false; - if (action != null) - { - result = action(); - } - this.CommandType = oldCommandType; - this.IsClearParameters = true; - return result; - } public IAdo UseStoredProcedure() { this.OldCommandType = this.CommandType; @@ -442,6 +416,135 @@ namespace SqlSugar SetConnectionEnd(sql); } } + + public virtual async Task ExecuteCommandAsync(string sql, params SugarParameter[] parameters) + { + try + { + InitParameters(ref sql, parameters); + if (FormatSql != null) + sql = FormatSql(sql); + SetConnectionStart(sql); + if (this.ProcessingEventStartingSQL != null) + ExecuteProcessingSQL(ref sql, parameters); + ExecuteBefore(sql, parameters); + var sqlCommand = GetCommand(sql, parameters); + int count = await sqlCommand.ExecuteNonQueryAsync(); + if (this.IsClearParameters) + sqlCommand.Parameters.Clear(); + ExecuteAfter(sql, parameters); + return count; + } + catch (Exception ex) + { + CommandType = CommandType.Text; + if (ErrorEvent != null) + ExecuteErrorEvent(sql, parameters, ex); + throw ex; + } + finally + { + if (this.IsAutoClose()) this.Close(); + SetConnectionEnd(sql); + } + } + public virtual async Task GetDataReaderAsync(string sql, params SugarParameter[] parameters) + { + try + { + InitParameters(ref sql, parameters); + if (FormatSql != null) + sql = FormatSql(sql); + SetConnectionStart(sql); + var isSp = this.CommandType == CommandType.StoredProcedure; + if (this.ProcessingEventStartingSQL != null) + ExecuteProcessingSQL(ref sql, parameters); + ExecuteBefore(sql, parameters); + var sqlCommand = GetCommand(sql, parameters); + var sqlDataReader = await sqlCommand.ExecuteReaderAsync(this.IsAutoClose() ? CommandBehavior.CloseConnection : CommandBehavior.Default); + if (isSp) + DataReaderParameters = sqlCommand.Parameters; + if (this.IsClearParameters) + sqlCommand.Parameters.Clear(); + ExecuteAfter(sql, parameters); + SetConnectionEnd(sql); + return sqlDataReader; + } + catch (Exception ex) + { + CommandType = CommandType.Text; + if (ErrorEvent != null) + ExecuteErrorEvent(sql, parameters, ex); + throw ex; + } + } + public virtual async Task GetDataReaderNoCloseAsync(string sql, params SugarParameter[] parameters) + { + try + { + InitParameters(ref sql, parameters); + if (FormatSql != null) + sql = FormatSql(sql); + SetConnectionStart(sql); + var isSp = this.CommandType == CommandType.StoredProcedure; + if (this.ProcessingEventStartingSQL != null) + ExecuteProcessingSQL(ref sql, parameters); + ExecuteBefore(sql, parameters); + var sqlCommand = GetCommand(sql, parameters); + var sqlDataReader = await sqlCommand.ExecuteReaderAsync(); + if (isSp) + DataReaderParameters = sqlCommand.Parameters; + if (this.IsClearParameters) + sqlCommand.Parameters.Clear(); + ExecuteAfter(sql, parameters); + SetConnectionEnd(sql); + return sqlDataReader; + } + catch (Exception ex) + { + CommandType = CommandType.Text; + if (ErrorEvent != null) + ExecuteErrorEvent(sql, parameters, ex); + throw ex; + } + } + public virtual async Task GetScalarAsync(string sql, params SugarParameter[] parameters) + { + try + { + InitParameters(ref sql, parameters); + if (FormatSql != null) + sql = FormatSql(sql); + SetConnectionStart(sql); + if (this.ProcessingEventStartingSQL != null) + ExecuteProcessingSQL(ref sql, parameters); + ExecuteBefore(sql, parameters); + var sqlCommand = GetCommand(sql, parameters); + var scalar = await sqlCommand.ExecuteScalarAsync(); + //scalar = (scalar == null ? 0 : scalar); + if (this.IsClearParameters) + sqlCommand.Parameters.Clear(); + ExecuteAfter(sql, parameters); + return scalar; + } + catch (Exception ex) + { + CommandType = CommandType.Text; + if (ErrorEvent != null) + ExecuteErrorEvent(sql, parameters, ex); + throw ex; + } + finally + { + if (this.IsAutoClose()) this.Close(); + SetConnectionEnd(sql); + } + } + public virtual Task GetDataSetAllAsync(string sql, params SugarParameter[] parameters) + { + //False asynchrony . No Support DataSet + return Task.FromResult(GetDataSetAll(sql, parameters)); + } #endregion #region Methods @@ -465,17 +568,43 @@ namespace SqlSugar return GetString(sql, parameters.ToArray()); } } - public virtual int GetInt(string sql, object parameters) + + + public virtual Task GetStringAsync(string sql, object parameters) { - return GetInt(sql, this.GetParameters(parameters)); + return GetStringAsync(sql, this.GetParameters(parameters)); } - public virtual long GetLong(string sql, object parameters) + public virtual async Task GetStringAsync(string sql, params SugarParameter[] parameters) + { + return Convert.ToString(await GetScalarAsync(sql, parameters)); + } + public virtual Task GetStringAsync(string sql, List parameters) + { + if (parameters == null) + { + return GetStringAsync(sql); + } + else + { + return GetStringAsync(sql, parameters.ToArray()); + } + } + + + + public virtual long GetLong(string sql, object parameters = null) { return Convert.ToInt64(GetScalar(sql, GetParameters(parameters))); } - public virtual int GetInt(string sql, params SugarParameter[] parameters) + public virtual async Task GetLongAsync(string sql, object parameters = null) { - return GetScalar(sql, parameters).ObjToInt(); + return Convert.ToInt64(await GetScalarAsync(sql, GetParameters(parameters))); + } + + + public virtual int GetInt(string sql, object parameters) + { + return GetInt(sql, this.GetParameters(parameters)); } public virtual int GetInt(string sql, List parameters) { @@ -488,6 +617,32 @@ namespace SqlSugar return GetInt(sql, parameters.ToArray()); } } + public virtual int GetInt(string sql, params SugarParameter[] parameters) + { + return GetScalar(sql, parameters).ObjToInt(); + } + + public virtual Task GetIntAsync(string sql, object parameters) + { + return GetIntAsync(sql, this.GetParameters(parameters)); + } + public virtual Task GetIntAsync(string sql, List parameters) + { + if (parameters == null) + { + return GetIntAsync(sql); + } + else + { + return GetIntAsync(sql, parameters.ToArray()); + } + } + public virtual async Task GetIntAsync(string sql, params SugarParameter[] parameters) + { + var list = await GetScalarAsync(sql, parameters); + return list.ObjToInt(); + } + public virtual Double GetDouble(string sql, object parameters) { return GetDouble(sql, this.GetParameters(parameters)); @@ -507,6 +662,29 @@ namespace SqlSugar return GetDouble(sql, parameters.ToArray()); } } + + public virtual Task GetDoubleAsync(string sql, object parameters) + { + return GetDoubleAsync(sql, this.GetParameters(parameters)); + } + public virtual async Task GetDoubleAsync(string sql, params SugarParameter[] parameters) + { + var result = await GetScalarAsync(sql, parameters); + return result.ObjToMoney(); + } + public virtual Task GetDoubleAsync(string sql, List parameters) + { + if (parameters == null) + { + return GetDoubleAsync(sql); + } + else + { + return GetDoubleAsync(sql, parameters.ToArray()); + } + } + + public virtual decimal GetDecimal(string sql, object parameters) { return GetDecimal(sql, this.GetParameters(parameters)); @@ -526,6 +704,31 @@ namespace SqlSugar return GetDecimal(sql, parameters.ToArray()); } } + + + public virtual Task GetDecimalAsync(string sql, object parameters) + { + return GetDecimalAsync(sql, this.GetParameters(parameters)); + } + public virtual async Task GetDecimalAsync(string sql, params SugarParameter[] parameters) + { + var result = await GetScalarAsync(sql, parameters); + return result.ObjToDecimal(); + } + public virtual Task GetDecimalAsync(string sql, List parameters) + { + if (parameters == null) + { + return GetDecimalAsync(sql); + } + else + { + return GetDecimalAsync(sql, parameters.ToArray()); + } + } + + + public virtual DateTime GetDateTime(string sql, object parameters) { return GetDateTime(sql, this.GetParameters(parameters)); @@ -545,6 +748,32 @@ namespace SqlSugar return GetDateTime(sql, parameters.ToArray()); } } + + + + + public virtual Task GetDateTimeAsync(string sql, object parameters) + { + return GetDateTimeAsync(sql, this.GetParameters(parameters)); + } + public virtual async Task GetDateTimeAsync(string sql, params SugarParameter[] parameters) + { + var list = await GetScalarAsync(sql, parameters); + return list.ObjToDate(); + } + public virtual Task GetDateTimeAsync(string sql, List parameters) + { + if (parameters == null) + { + return GetDateTimeAsync(sql); + } + else + { + return GetDateTimeAsync(sql, parameters.ToArray()); + } + } + + public virtual List SqlQuery(string sql, object parameters = null) { var sugarParameters = this.GetParameters(parameters); @@ -552,37 +781,9 @@ namespace SqlSugar } public virtual List SqlQuery(string sql, params SugarParameter[] parameters) { - this.Context.InitMappingInfo(); - var builder = InstanceFactory.GetSqlbuilder(this.Context.CurrentConnectionConfig); - builder.SqlQueryBuilder.sql.Append(sql); - if (parameters != null && parameters.Any()) - builder.SqlQueryBuilder.Parameters.AddRange(parameters); - var dataReader = this.GetDataReader(builder.SqlQueryBuilder.ToSqlString(), builder.SqlQueryBuilder.Parameters.ToArray()); - List result = null; - if (typeof(T) == UtilConstants.ObjType) - { - result = this.Context.Utilities.DataReaderToExpandoObjectList(dataReader).Select(it => ((T)(object)it)).ToList(); - } - else - { - result=this.DbBind.DataReaderToList(typeof(T), dataReader); - } - builder.SqlQueryBuilder.Clear(); - if (this.Context.Ado.DataReaderParameters != null) - { - foreach (IDataParameter item in this.Context.Ado.DataReaderParameters) - { - var parameter = parameters.FirstOrDefault(it => item.ParameterName.Substring(1) == it.ParameterName.Substring(1)); - if (parameter != null) - { - parameter.Value = item.Value; - } - } - this.Context.Ado.DataReaderParameters = null; - } - return result; + var result = SqlQuery(sql, parameters); + return result.Item1; } - public virtual List SqlQuery(string sql, List parameters) { if (parameters != null) @@ -596,173 +797,29 @@ namespace SqlSugar } public Tuple, List> SqlQuery(string sql, object parameters = null) { - var parsmeterArray = this.GetParameters(parameters); - this.Context.InitMappingInfo(); - var builder = InstanceFactory.GetSqlbuilder(this.Context.CurrentConnectionConfig); - builder.SqlQueryBuilder.sql.Append(sql); - if (parsmeterArray != null && parsmeterArray.Any()) - builder.SqlQueryBuilder.Parameters.AddRange(parsmeterArray); - using (var dataReader = this.GetDataReaderNoClose(builder.SqlQueryBuilder.ToSqlString(), builder.SqlQueryBuilder.Parameters.ToArray())) - { - List result = this.DbBind.DataReaderToListNoUsing(typeof(T), dataReader); - NextResult(dataReader); - List result2 = this.DbBind.DataReaderToListNoUsing(typeof(T2), dataReader); - builder.SqlQueryBuilder.Clear(); - if (this.Context.Ado.DataReaderParameters != null) - { - foreach (IDataParameter item in this.Context.Ado.DataReaderParameters) - { - var parameter = parsmeterArray.FirstOrDefault(it => item.ParameterName.Substring(1) == it.ParameterName.Substring(1)); - if (parameter != null) - { - parameter.Value = item.Value; - } - } - this.Context.Ado.DataReaderParameters = null; - } - return Tuple.Create, List>(result, result2); - } + var result = SqlQuery(sql, parameters); + return new Tuple, List>(result.Item1, result.Item2); } - public Tuple, List, List> SqlQuery(string sql, object parameters = null) { - var parsmeterArray = this.GetParameters(parameters); - this.Context.InitMappingInfo(); - var builder = InstanceFactory.GetSqlbuilder(this.Context.CurrentConnectionConfig); - builder.SqlQueryBuilder.sql.Append(sql); - if (parsmeterArray != null && parsmeterArray.Any()) - builder.SqlQueryBuilder.Parameters.AddRange(parsmeterArray); - using (var dataReader = this.GetDataReaderNoClose(builder.SqlQueryBuilder.ToSqlString(), builder.SqlQueryBuilder.Parameters.ToArray())) - { - List result = this.DbBind.DataReaderToListNoUsing(typeof(T), dataReader); - NextResult(dataReader); - List result2 = this.DbBind.DataReaderToListNoUsing(typeof(T2), dataReader); - NextResult(dataReader); - List result3 = this.DbBind.DataReaderToListNoUsing(typeof(T3), dataReader); - builder.SqlQueryBuilder.Clear(); - if (this.Context.Ado.DataReaderParameters != null) - { - foreach (IDataParameter item in this.Context.Ado.DataReaderParameters) - { - var parameter = parsmeterArray.FirstOrDefault(it => item.ParameterName.Substring(1) == it.ParameterName.Substring(1)); - if (parameter != null) - { - parameter.Value = item.Value; - } - } - this.Context.Ado.DataReaderParameters = null; - } - return Tuple.Create, List, List>(result, result2, result3); - } + var result = SqlQuery(sql, parameters); + return new Tuple, List, List>(result.Item1, result.Item2, result.Item3); } - public Tuple, List, List, List> SqlQuery(string sql, object parameters = null) { - var parsmeterArray = this.GetParameters(parameters); - this.Context.InitMappingInfo(); - var builder = InstanceFactory.GetSqlbuilder(this.Context.CurrentConnectionConfig); - builder.SqlQueryBuilder.sql.Append(sql); - if (parsmeterArray != null && parsmeterArray.Any()) - builder.SqlQueryBuilder.Parameters.AddRange(parsmeterArray); - using (var dataReader = this.GetDataReaderNoClose(builder.SqlQueryBuilder.ToSqlString(), builder.SqlQueryBuilder.Parameters.ToArray())) - { - List result = this.DbBind.DataReaderToListNoUsing(typeof(T), dataReader); - NextResult(dataReader); - List result2 = this.DbBind.DataReaderToListNoUsing(typeof(T2), dataReader); - NextResult(dataReader); - List result3 = this.DbBind.DataReaderToListNoUsing(typeof(T3), dataReader); - NextResult(dataReader); - List result4 = this.DbBind.DataReaderToListNoUsing(typeof(T4), dataReader); - builder.SqlQueryBuilder.Clear(); - if (this.Context.Ado.DataReaderParameters != null) - { - foreach (IDataParameter item in this.Context.Ado.DataReaderParameters) - { - var parameter = parsmeterArray.FirstOrDefault(it => item.ParameterName.Substring(1) == it.ParameterName.Substring(1)); - if (parameter != null) - { - parameter.Value = item.Value; - } - } - this.Context.Ado.DataReaderParameters = null; - } - return Tuple.Create, List, List, List>(result, result2, result3, result4); - } + var result = SqlQuery(sql, parameters); + return new Tuple, List, List, List>(result.Item1, result.Item2, result.Item3, result.Item4); } public Tuple, List, List, List, List> SqlQuery(string sql, object parameters = null) { - var parsmeterArray = this.GetParameters(parameters); - this.Context.InitMappingInfo(); - var builder = InstanceFactory.GetSqlbuilder(this.Context.CurrentConnectionConfig); - builder.SqlQueryBuilder.sql.Append(sql); - if (parsmeterArray != null && parsmeterArray.Any()) - builder.SqlQueryBuilder.Parameters.AddRange(parsmeterArray); - using (var dataReader = this.GetDataReaderNoClose(builder.SqlQueryBuilder.ToSqlString(), builder.SqlQueryBuilder.Parameters.ToArray())) - { - List result = this.DbBind.DataReaderToListNoUsing(typeof(T), dataReader); - NextResult(dataReader); - List result2 = this.DbBind.DataReaderToListNoUsing(typeof(T2), dataReader); - NextResult(dataReader); - List result3 = this.DbBind.DataReaderToListNoUsing(typeof(T3), dataReader); - NextResult(dataReader); - List result4 = this.DbBind.DataReaderToListNoUsing(typeof(T4), dataReader); - NextResult(dataReader); - List result5 = this.DbBind.DataReaderToListNoUsing(typeof(T5), dataReader); - builder.SqlQueryBuilder.Clear(); - if (this.Context.Ado.DataReaderParameters != null) - { - foreach (IDataParameter item in this.Context.Ado.DataReaderParameters) - { - var parameter = parsmeterArray.FirstOrDefault(it => item.ParameterName.Substring(1) == it.ParameterName.Substring(1)); - if (parameter != null) - { - parameter.Value = item.Value; - } - } - this.Context.Ado.DataReaderParameters = null; - } - return Tuple.Create, List, List, List, List>(result, result2, result3, result4, result5); - } + var result = SqlQuery(sql, parameters); + return new Tuple, List, List, List, List>(result.Item1, result.Item2, result.Item3, result.Item4, result.Item5); } - public Tuple, List, List, List, List, List> SqlQuery(string sql, object parameters = null) { - var parsmeterArray = this.GetParameters(parameters); - this.Context.InitMappingInfo(); - var builder = InstanceFactory.GetSqlbuilder(this.Context.CurrentConnectionConfig); - builder.SqlQueryBuilder.sql.Append(sql); - if (parsmeterArray != null && parsmeterArray.Any()) - builder.SqlQueryBuilder.Parameters.AddRange(parsmeterArray); - using (var dataReader = this.GetDataReaderNoClose(builder.SqlQueryBuilder.ToSqlString(), builder.SqlQueryBuilder.Parameters.ToArray())) - { - List result = this.DbBind.DataReaderToListNoUsing(typeof(T), dataReader); - NextResult(dataReader); - List result2 = this.DbBind.DataReaderToListNoUsing(typeof(T2), dataReader); - NextResult(dataReader); - List result3 = this.DbBind.DataReaderToListNoUsing(typeof(T3), dataReader); - NextResult(dataReader); - List result4 = this.DbBind.DataReaderToListNoUsing(typeof(T4), dataReader); - NextResult(dataReader); - List result5 = this.DbBind.DataReaderToListNoUsing(typeof(T5), dataReader); - NextResult(dataReader); - List result6 = this.DbBind.DataReaderToListNoUsing(typeof(T6), dataReader); - builder.SqlQueryBuilder.Clear(); - if (this.Context.Ado.DataReaderParameters != null) - { - foreach (IDataParameter item in this.Context.Ado.DataReaderParameters) - { - var parameter = parsmeterArray.FirstOrDefault(it => item.ParameterName.Substring(1) == it.ParameterName.Substring(1)); - if (parameter != null) - { - parameter.Value = item.Value; - } - } - this.Context.Ado.DataReaderParameters = null; - } - return Tuple.Create, List, List, List, List, List>(result, result2, result3, result4, result5, result6); - } + var result = SqlQuery(sql, parameters); + return new Tuple, List, List, List, List, List>(result.Item1, result.Item2, result.Item3, result.Item4, result.Item5, result.Item6); } - public Tuple, List, List, List, List, List, List> SqlQuery(string sql, object parameters = null) { var parsmeterArray = this.GetParameters(parameters); @@ -773,19 +830,54 @@ namespace SqlSugar builder.SqlQueryBuilder.Parameters.AddRange(parsmeterArray); using (var dataReader = this.GetDataReaderNoClose(builder.SqlQueryBuilder.ToSqlString(), builder.SqlQueryBuilder.Parameters.ToArray())) { - List result = this.DbBind.DataReaderToListNoUsing(typeof(T), dataReader); - NextResult(dataReader); - List result2 = this.DbBind.DataReaderToListNoUsing(typeof(T2), dataReader); - NextResult(dataReader); - List result3 = this.DbBind.DataReaderToListNoUsing(typeof(T3), dataReader); - NextResult(dataReader); - List result4 = this.DbBind.DataReaderToListNoUsing(typeof(T4), dataReader); - NextResult(dataReader); - List result5 = this.DbBind.DataReaderToListNoUsing(typeof(T5), dataReader); - NextResult(dataReader); - List result6 = this.DbBind.DataReaderToListNoUsing(typeof(T6), dataReader); - NextResult(dataReader); - List result7 = this.DbBind.DataReaderToListNoUsing(typeof(T7), dataReader); + DbDataReader DbReader = (DbDataReader)dataReader; + List result = new List(); + if (DbReader.HasRows) + { + result = GetData(typeof(T), dataReader); + } + List result2 = null; + if (DbReader.HasRows) + { + this.Context.InitMappingInfo(); + NextResult(dataReader); + result2 = GetData(typeof(T2), dataReader); + } + List result3 = null; + if (DbReader.HasRows) + { + this.Context.InitMappingInfo(); + NextResult(dataReader); + result3 = GetData(typeof(T3), dataReader); + } + List result4 = null; + if (DbReader.HasRows) + { + this.Context.InitMappingInfo(); + NextResult(dataReader); + result4 = GetData(typeof(T4), dataReader); + } + List result5 = null; + if (DbReader.HasRows) + { + this.Context.InitMappingInfo(); + NextResult(dataReader); + result5 = GetData(typeof(T5), dataReader); + } + List result6 = null; + if (DbReader.HasRows) + { + this.Context.InitMappingInfo(); + NextResult(dataReader); + result6 = GetData(typeof(T6), dataReader); + } + List result7 = null; + if (DbReader.HasRows) + { + this.Context.InitMappingInfo(); + NextResult(dataReader); + result7 = GetData(typeof(T7), dataReader); + } builder.SqlQueryBuilder.Clear(); if (this.Context.Ado.DataReaderParameters != null) { @@ -803,17 +895,127 @@ namespace SqlSugar } } - private static void NextResult(IDataReader dataReader) + public virtual Task> SqlQueryAsync(string sql, object parameters = null) { - try + var sugarParameters = this.GetParameters(parameters); + return SqlQueryAsync(sql, sugarParameters); + } + public virtual async Task> SqlQueryAsync(string sql, params SugarParameter[] parameters) + { + var result = await SqlQueryAsync(sql, parameters); + return result.Item1; + } + public virtual Task> SqlQueryAsync(string sql, List parameters) + { + if (parameters != null) { - dataReader.NextResult(); + return SqlQueryAsync(sql, parameters.ToArray()); } - catch + else { - Check.Exception(true, ErrorMessage.GetThrowMessage("Please reduce the number of T. Save Queue Changes queries don't have so many results", "请减少T的数量，SaveQueueChanges 查询没有这么多结果")); + return SqlQueryAsync(sql); } } + public async Task, List>> SqlQueryAsync(string sql, object parameters = null) + { + var result = await SqlQueryAsync(sql, parameters); + return new Tuple, List>(result.Item1, result.Item2); + } + public async Task, List, List>> SqlQueryAsync(string sql, object parameters = null) + { + var result = await SqlQueryAsync(sql, parameters); + return new Tuple, List, List>(result.Item1, result.Item2, result.Item3); + } + public async Task, List, List, List>> SqlQueryAsync(string sql, object parameters = null) + { + var result = await SqlQueryAsync(sql, parameters); + return new Tuple, List, List, List>(result.Item1, result.Item2, result.Item3, result.Item4); + } + public async Task, List, List, List, List>> SqlQueryAsync(string sql, object parameters = null) + { + var result = await SqlQueryAsync(sql, parameters); + return new Tuple, List, List, List, List>(result.Item1, result.Item2, result.Item3, result.Item4, result.Item5); + } + public async Task, List, List, List, List, List>> SqlQueryAsync(string sql, object parameters = null) + { + var result =await SqlQueryAsync(sql, parameters); + return new Tuple, List, List, List, List, List>(result.Item1, result.Item2, result.Item3, result.Item4, result.Item5, result.Item6); + } + public async Task, List, List, List, List, List, List>> SqlQueryAsync(string sql, object parameters = null) + { + var parsmeterArray = this.GetParameters(parameters); + this.Context.InitMappingInfo(); + var builder = InstanceFactory.GetSqlbuilder(this.Context.CurrentConnectionConfig); + builder.SqlQueryBuilder.sql.Append(sql); + if (parsmeterArray != null && parsmeterArray.Any()) + builder.SqlQueryBuilder.Parameters.AddRange(parsmeterArray); + using (var dataReader = await this.GetDataReaderNoCloseAsync(builder.SqlQueryBuilder.ToSqlString(), builder.SqlQueryBuilder.Parameters.ToArray())) + { + DbDataReader DbReader = (DbDataReader)dataReader; + List result = new List(); + if (DbReader.HasRows) + { + result =await GetDataAsync(typeof(T), dataReader); + } + List result2 = null; + if (DbReader.HasRows) + { + this.Context.InitMappingInfo(); + NextResult(dataReader); + result2 = await GetDataAsync(typeof(T2), dataReader); + } + List result3 = null; + if (DbReader.HasRows) + { + this.Context.InitMappingInfo(); + NextResult(dataReader); + result3 = await GetDataAsync(typeof(T3), dataReader); + } + List result4 = null; + if (DbReader.HasRows) + { + this.Context.InitMappingInfo(); + NextResult(dataReader); + result4 = await GetDataAsync(typeof(T4), dataReader); + } + List result5 = null; + if (DbReader.HasRows) + { + this.Context.InitMappingInfo(); + NextResult(dataReader); + result5 = await GetDataAsync(typeof(T5), dataReader); + } + List result6 = null; + if (DbReader.HasRows) + { + this.Context.InitMappingInfo(); + NextResult(dataReader); + result6 = await GetDataAsync(typeof(T6), dataReader); + } + List result7 = null; + if (DbReader.HasRows) + { + this.Context.InitMappingInfo(); + NextResult(dataReader); + result7 = await GetDataAsync(typeof(T7), dataReader); + } + builder.SqlQueryBuilder.Clear(); + if (this.Context.Ado.DataReaderParameters != null) + { + foreach (IDataParameter item in this.Context.Ado.DataReaderParameters) + { + var parameter = parsmeterArray.FirstOrDefault(it => item.ParameterName.Substring(1) == it.ParameterName.Substring(1)); + if (parameter != null) + { + parameter.Value = item.Value; + } + } + this.Context.Ado.DataReaderParameters = null; + } + return Tuple.Create, List, List, List, List, List, List>(result, result2, result3, result4, result5, result6, result7); + } + } + public virtual T SqlQuerySingle(string sql, object parameters = null) { var result = SqlQuery(sql, parameters); @@ -829,21 +1031,26 @@ namespace SqlSugar var result = SqlQuery(sql, parameters); return result == null ? default(T) : result.FirstOrDefault(); } - public virtual dynamic SqlQueryDynamic(string sql, object parameters = null) + + + public virtual async Task SqlQuerySingleAsync(string sql, object parameters = null) { - var dt = this.GetDataTable(sql, parameters); - return dt == null ? null : this.Context.Utilities.DataTableToDynamic(dt); + var result = await SqlQueryAsync(sql, parameters); + return result == null ? default(T) : result.FirstOrDefault(); } - public virtual dynamic SqlQueryDynamic(string sql, params SugarParameter[] parameters) + public virtual async Task SqlQuerySingleAsync(string sql, params SugarParameter[] parameters) { - var dt = this.GetDataTable(sql, parameters); - return dt == null ? null : this.Context.Utilities.DataTableToDynamic(dt); + var result = await SqlQueryAsync(sql, parameters); + return result == null ? default(T) : result.FirstOrDefault(); } - public dynamic SqlQueryDynamic(string sql, List parameters) + public virtual async Task SqlQuerySingleAsync(string sql, List parameters) { - var dt = this.GetDataTable(sql, parameters); - return dt == null ? null : this.Context.Utilities.DataTableToDynamic(dt); + var result = await SqlQueryAsync(sql, parameters); + return result == null ? default(T) : result.FirstOrDefault(); } + + + public virtual DataTable GetDataTable(string sql, params SugarParameter[] parameters) { var ds = GetDataSetAll(sql, parameters); @@ -865,6 +1072,31 @@ namespace SqlSugar return GetDataTable(sql, parameters.ToArray()); } } + + + public virtual async Task GetDataTableAsync(string sql, params SugarParameter[] parameters) + { + var ds = await GetDataSetAllAsync(sql, parameters); + if (ds.Tables.Count != 0 && ds.Tables.Count > 0) return ds.Tables[0]; + return new DataTable(); + } + public virtual Task GetDataTableAsync(string sql, object parameters) + { + return GetDataTableAsync(sql, this.GetParameters(parameters)); + } + public virtual Task GetDataTableAsync(string sql, List parameters) + { + if (parameters == null) + { + return GetDataTableAsync(sql); + } + else + { + return GetDataTableAsync(sql, parameters.ToArray()); + } + } + + public virtual DataSet GetDataSetAll(string sql, object parameters) { return GetDataSetAll(sql, this.GetParameters(parameters)); @@ -880,6 +1112,26 @@ namespace SqlSugar return GetDataSetAll(sql, parameters.ToArray()); } } + + public virtual Task GetDataSetAllAsync(string sql, object parameters) + { + return GetDataSetAllAsync(sql, this.GetParameters(parameters)); + } + public virtual Task GetDataSetAllAsync(string sql, List parameters) + { + if (parameters == null) + { + return GetDataSetAllAsync(sql); + } + else + { + return GetDataSetAllAsync(sql, parameters.ToArray()); + } + } + + + + public virtual IDataReader GetDataReader(string sql, object parameters) { return GetDataReader(sql, this.GetParameters(parameters)); @@ -895,6 +1147,21 @@ namespace SqlSugar return GetDataReader(sql, parameters.ToArray()); } } + public virtual Task GetDataReaderAsync(string sql, object parameters) + { + return GetDataReaderAsync(sql, this.GetParameters(parameters)); + } + public virtual Task GetDataReaderAsync(string sql, List parameters) + { + if (parameters == null) + { + return GetDataReaderAsync(sql); + } + else + { + return GetDataReaderAsync(sql, parameters.ToArray()); + } + } public virtual object GetScalar(string sql, object parameters) { return GetScalar(sql, this.GetParameters(parameters)); @@ -910,6 +1177,21 @@ namespace SqlSugar return GetScalar(sql, parameters.ToArray()); } } + public virtual Task GetScalarAsync(string sql, object parameters) + { + return GetScalarAsync(sql, this.GetParameters(parameters)); + } + public virtual Task GetScalarAsync(string sql, List parameters) + { + if (parameters == null) + { + return GetScalarAsync(sql); + } + else + { + return GetScalarAsync(sql, parameters.ToArray()); + } + } public virtual int ExecuteCommand(string sql, object parameters) { return ExecuteCommand(sql, GetParameters(parameters)); @@ -925,17 +1207,35 @@ namespace SqlSugar return ExecuteCommand(sql, parameters.ToArray()); } } + public virtual Task ExecuteCommandAsync(string sql, object parameters) + { + return ExecuteCommandAsync(sql, GetParameters(parameters)); + } + public virtual Task ExecuteCommandAsync(string sql, List parameters) + { + if (parameters == null) + { + return ExecuteCommandAsync(sql); + } + else + { + return ExecuteCommandAsync(sql, parameters.ToArray()); + } + } #endregion #region Helper - //private void TaskStart(Task result) - //{ - // if (this.Context.CurrentConnectionConfig.IsShardSameThread) - // { - // Check.Exception(true, "IsShardSameThread=true can't be used async method"); - // } - // result.Start(); - //} + private static void NextResult(IDataReader dataReader) + { + try + { + dataReader.NextResult(); + } + catch + { + Check.Exception(true, ErrorMessage.GetThrowMessage("Please reduce the number of T. Save Queue Changes queries don't have so many results", "请减少T的数量，SaveQueueChanges 查询没有这么多结果")); + } + } private void ExecuteProcessingSQL(ref string sql, SugarParameter[] parameters) { var result = this.ProcessingEventStartingSQL(sql, parameters); @@ -1117,6 +1417,98 @@ namespace SqlSugar } } } + private List GetData(Type entityType, IDataReader dataReader) + { + List result; + if (entityType == UtilConstants.DynamicType) + { + result = this.Context.Utilities.DataReaderToExpandoObjectListNoUsing(dataReader) as List; + } + else if (entityType == UtilConstants.ObjType) + { + result = this.Context.Utilities.DataReaderToExpandoObjectListNoUsing(dataReader).Select(it => ((TResult)(object)it)).ToList(); + } + else if (entityType.IsAnonymousType()) + { + result = this.Context.Utilities.DataReaderToListNoUsing(dataReader); + } + else + { + result = this.Context.Ado.DbBind.DataReaderToListNoUsing(entityType, dataReader); + } + return result; + } + private async Task> GetDataAsync(Type entityType, IDataReader dataReader) + { + List result; + if (entityType == UtilConstants.DynamicType) + { + result =await this.Context.Utilities.DataReaderToExpandoObjectListAsyncNoUsing(dataReader) as List; + } + else if (entityType == UtilConstants.ObjType) + { + var list = await this.Context.Utilities.DataReaderToExpandoObjectListAsyncNoUsing(dataReader); + result = list.Select(it => ((TResult)(object)it)).ToList(); + } + else if (entityType.IsAnonymousType()) + { + result =await this.Context.Utilities.DataReaderToListAsyncNoUsing(dataReader); + } + else + { + result =await this.Context.Ado.DbBind.DataReaderToListNoUsingAsync(entityType, dataReader); + } + return result; + } + #endregion + + #region Obsolete + [Obsolete] + public virtual dynamic SqlQueryDynamic(string sql, object parameters = null) + { + var dt = this.GetDataTable(sql, parameters); + return dt == null ? null : this.Context.Utilities.DataTableToDynamic(dt); + } + [Obsolete] + public virtual dynamic SqlQueryDynamic(string sql, params SugarParameter[] parameters) + { + var dt = this.GetDataTable(sql, parameters); + return dt == null ? null : this.Context.Utilities.DataTableToDynamic(dt); + } + [Obsolete] + public dynamic SqlQueryDynamic(string sql, List parameters) + { + var dt = this.GetDataTable(sql, parameters); + return dt == null ? null : this.Context.Utilities.DataTableToDynamic(dt); + } + [Obsolete] + public void UseStoredProcedure(Action action) + { + var oldCommandType = this.CommandType; + this.CommandType = CommandType.StoredProcedure; + this.IsClearParameters = false; + if (action != null) + { + action(); + } + this.CommandType = oldCommandType; + this.IsClearParameters = true; + } + [Obsolete] + public T UseStoredProcedure(Func action) + { + T result = default(T); + var oldCommandType = this.CommandType; + this.CommandType = CommandType.StoredProcedure; + this.IsClearParameters = false; + if (action != null) + { + result = action(); + } + this.CommandType = oldCommandType; + this.IsClearParameters = true; + return result; + } #endregion } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbBindProvider/DbBindAccessory.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbBindProvider/DbBindAccessory.cs index 9df4b89c6..2d1df66ba 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbBindProvider/DbBindAccessory.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbBindProvider/DbBindAccessory.cs @@ -1,8 +1,11 @@ using System; using System.Collections.Generic; using System.Data; +using System.Data.Common; using System.Linq; using System.Text; +using System.Threading.Tasks; + namespace SqlSugar { public partial class DbBindAccessory @@ -32,6 +35,31 @@ namespace SqlSugar } return result; } + protected async Task> GetEntityListAsync(SqlSugarProvider context, IDataReader dataReader) + { + Type type = typeof(T); + var fieldNames = GetDataReaderNames(dataReader); + string cacheKey = GetCacheKey(type, fieldNames); + IDataReaderEntityBuilder entytyList = context.Utilities.GetReflectionInoCacheInstance().GetOrCreate(cacheKey, () => + { + var cacheResult = new IDataReaderEntityBuilder(context, dataReader, fieldNames).CreateBuilder(type); + return cacheResult; + }); + List result = new List(); + try + { + if (dataReader == null) return result; + while (await((DbDataReader)dataReader).ReadAsync()) + { + result.Add(entytyList.Build(dataReader)); + } + } + catch (Exception ex) + { + Check.Exception(true, ErrorMessage.EntityMappingError, ex.Message); + } + return result; + } private string GetCacheKey(Type type,List keys) { @@ -61,40 +89,68 @@ namespace SqlSugar List result = new List(); while (dataReader.Read()) { - if (UtilConstants.DicOO == type) - { - var kv = new KeyValuePair(dataReader.GetValue(0), dataReader.GetValue(1)); - result.Add((T)Convert.ChangeType(kv, typeof(KeyValuePair))); - } - else if (UtilConstants.DicIS == type) - { - var kv = new KeyValuePair(dataReader.GetValue(0).ObjToInt(), dataReader.GetValue(1).ObjToString()); - result.Add((T)Convert.ChangeType(kv, typeof(KeyValuePair))); - } - else if (UtilConstants.Dicii == type) - { - var kv = new KeyValuePair(dataReader.GetValue(0).ObjToInt(), dataReader.GetValue(1).ObjToInt()); - result.Add((T)Convert.ChangeType(kv, typeof(KeyValuePair))); - } - else if (UtilConstants.DicSi == type) - { - var kv = new KeyValuePair(dataReader.GetValue(0).ObjToString(), dataReader.GetValue(1).ObjToInt()); - result.Add((T)Convert.ChangeType(kv, typeof(KeyValuePair))); - } - else if (UtilConstants.DicSo == type) - { - var kv = new KeyValuePair(dataReader.GetValue(0).ObjToString(), dataReader.GetValue(1)); - result.Add((T)Convert.ChangeType(kv, typeof(KeyValuePair))); - } - else if (UtilConstants.DicSS == type) - { - var kv = new KeyValuePair(dataReader.GetValue(0).ObjToString(), dataReader.GetValue(1).ObjToString()); - result.Add((T)Convert.ChangeType(kv, typeof(KeyValuePair))); - } - else - { - Check.Exception(true, ErrorMessage.NotSupportedDictionary); - } + GetKeyValueList(type, dataReader, result); + } + return result; + } + + protected async Task> GetKeyValueListAsync(Type type, IDataReader dataReader) + { + List result = new List(); + while (await ((DbDataReader)dataReader).ReadAsync()) + { + GetKeyValueList(type, dataReader, result); + } + return result; + } + + private static void GetKeyValueList(Type type, IDataReader dataReader, List result) + { + if (UtilConstants.DicOO == type) + { + var kv = new KeyValuePair(dataReader.GetValue(0), dataReader.GetValue(1)); + result.Add((T)Convert.ChangeType(kv, typeof(KeyValuePair))); + } + else if (UtilConstants.DicIS == type) + { + var kv = new KeyValuePair(dataReader.GetValue(0).ObjToInt(), dataReader.GetValue(1).ObjToString()); + result.Add((T)Convert.ChangeType(kv, typeof(KeyValuePair))); + } + else if (UtilConstants.Dicii == type) + { + var kv = new KeyValuePair(dataReader.GetValue(0).ObjToInt(), dataReader.GetValue(1).ObjToInt()); + result.Add((T)Convert.ChangeType(kv, typeof(KeyValuePair))); + } + else if (UtilConstants.DicSi == type) + { + var kv = new KeyValuePair(dataReader.GetValue(0).ObjToString(), dataReader.GetValue(1).ObjToInt()); + result.Add((T)Convert.ChangeType(kv, typeof(KeyValuePair))); + } + else if (UtilConstants.DicSo == type) + { + var kv = new KeyValuePair(dataReader.GetValue(0).ObjToString(), dataReader.GetValue(1)); + result.Add((T)Convert.ChangeType(kv, typeof(KeyValuePair))); + } + else if (UtilConstants.DicSS == type) + { + var kv = new KeyValuePair(dataReader.GetValue(0).ObjToString(), dataReader.GetValue(1).ObjToString()); + result.Add((T)Convert.ChangeType(kv, typeof(KeyValuePair))); + } + else + { + Check.Exception(true, ErrorMessage.NotSupportedDictionary); + } + } + + + protected async Task> GetArrayListAsync(Type type, IDataReader dataReader) + { + List result = new List(); + int count = dataReader.FieldCount; + var childType = type.GetElementType(); + while (await((DbDataReader)dataReader).ReadAsync()) + { + GetArrayList(type, dataReader, result, count, childType); } return result; } @@ -106,57 +162,78 @@ namespace SqlSugar var childType = type.GetElementType(); while (dataReader.Read()) { - object[] array = new object[count]; - for (int i = 0; i < count; i++) - { - array[i] = Convert.ChangeType(dataReader.GetValue(i), childType); - } - if (childType == UtilConstants.StringType) - result.Add((T)Convert.ChangeType(array.Select(it => it.ObjToString()).ToArray(), type)); - else if (childType == UtilConstants.ObjType) - result.Add((T)Convert.ChangeType(array.Select(it => it == DBNull.Value ? null : (object)it).ToArray(), type)); - else if (childType == UtilConstants.BoolType) - result.Add((T)Convert.ChangeType(array.Select(it => it.ObjToBool()).ToArray(), type)); - else if (childType == UtilConstants.ByteType) - result.Add((T)Convert.ChangeType(array.Select(it => it == DBNull.Value ? 0 : (byte)it).ToArray(), type)); - else if (childType == UtilConstants.DecType) - result.Add((T)Convert.ChangeType(array.Select(it => it.ObjToDecimal()).ToArray(), type)); - else if (childType == UtilConstants.GuidType) - result.Add((T)Convert.ChangeType(array.Select(it => it == DBNull.Value ? Guid.Empty : (Guid)it).ToArray(), type)); - else if (childType == UtilConstants.DateType) - result.Add((T)Convert.ChangeType(array.Select(it => it == DBNull.Value ? DateTime.MinValue : (DateTime)it).ToArray(), type)); - else if (childType == UtilConstants.IntType) - result.Add((T)Convert.ChangeType(array.Select(it => it.ObjToInt()).ToArray(), type)); - else - Check.Exception(true, ErrorMessage.NotSupportedArray); + GetArrayList(type, dataReader, result, count, childType); } return result; } + + + private static void GetArrayList(Type type, IDataReader dataReader, List result, int count, Type childType) + { + object[] array = new object[count]; + for (int i = 0; i < count; i++) + { + array[i] = Convert.ChangeType(dataReader.GetValue(i), childType); + } + if (childType == UtilConstants.StringType) + result.Add((T)Convert.ChangeType(array.Select(it => it.ObjToString()).ToArray(), type)); + else if (childType == UtilConstants.ObjType) + result.Add((T)Convert.ChangeType(array.Select(it => it == DBNull.Value ? null : (object)it).ToArray(), type)); + else if (childType == UtilConstants.BoolType) + result.Add((T)Convert.ChangeType(array.Select(it => it.ObjToBool()).ToArray(), type)); + else if (childType == UtilConstants.ByteType) + result.Add((T)Convert.ChangeType(array.Select(it => it == DBNull.Value ? 0 : (byte)it).ToArray(), type)); + else if (childType == UtilConstants.DecType) + result.Add((T)Convert.ChangeType(array.Select(it => it.ObjToDecimal()).ToArray(), type)); + else if (childType == UtilConstants.GuidType) + result.Add((T)Convert.ChangeType(array.Select(it => it == DBNull.Value ? Guid.Empty : (Guid)it).ToArray(), type)); + else if (childType == UtilConstants.DateType) + result.Add((T)Convert.ChangeType(array.Select(it => it == DBNull.Value ? DateTime.MinValue : (DateTime)it).ToArray(), type)); + else if (childType == UtilConstants.IntType) + result.Add((T)Convert.ChangeType(array.Select(it => it.ObjToInt()).ToArray(), type)); + else + Check.Exception(true, ErrorMessage.NotSupportedArray); + } + protected List GetValueTypeList(Type type, IDataReader dataReader) { List result = new List(); while (dataReader.Read()) { - var value = dataReader.GetValue(0); - if (type == UtilConstants.GuidType) - { - value = Guid.Parse(value.ToString()); - } - if (value == DBNull.Value) - { - result.Add(default(T)); - } - else if (type.IsEnum) - { - result.Add((T)Enum.Parse(type, value.ObjToString())); - } - else - { - result.Add((T)Convert.ChangeType(value, UtilMethods.GetUnderType(type))); - } + GetValueTypeList(type, dataReader, result); } return result; } + protected async Task> GetValueTypeListAsync(Type type, IDataReader dataReader) + { + List result = new List(); + while (await ((DbDataReader)dataReader).ReadAsync()) + { + GetValueTypeList(type, dataReader, result); + } + return result; + } + + private static void GetValueTypeList(Type type, IDataReader dataReader, List result) + { + var value = dataReader.GetValue(0); + if (type == UtilConstants.GuidType) + { + value = Guid.Parse(value.ToString()); + } + if (value == DBNull.Value) + { + result.Add(default(T)); + } + else if (type.IsEnum) + { + result.Add((T)Enum.Parse(type, value.ObjToString())); + } + else + { + result.Add((T)Convert.ChangeType(value, UtilMethods.GetUnderType(type))); + } + } } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbBindProvider/DbBindProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbBindProvider/DbBindProvider.cs index 37c339167..5e3064a7a 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbBindProvider/DbBindProvider.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbBindProvider/DbBindProvider.cs @@ -5,6 +5,8 @@ using System.Data.SqlClient; using System.Linq; using System.Reflection; using System.Text; +using System.Threading.Tasks; + namespace SqlSugar { public abstract partial class DbBindProvider : DbBindAccessory, IDbBind @@ -201,6 +203,28 @@ namespace SqlSugar } } } + public virtual async Task> DataReaderToListAsync(Type type, IDataReader dataReader) + { + using (dataReader) + { + if (type.Name.Contains("KeyValuePair")) + { + return await GetKeyValueListAsync(type, dataReader); + } + else if (type.IsValueType() || type == UtilConstants.StringType || type == UtilConstants.ByteArrayType) + { + return await GetValueTypeListAsync(type, dataReader); + } + else if (type.IsArray) + { + return await GetArrayListAsync(type, dataReader); + } + else + { + return await GetEntityListAsync(Context, dataReader); + } + } + } public virtual List DataReaderToListNoUsing(Type type, IDataReader dataReader) { if (type.Name.Contains("KeyValuePair")) @@ -220,6 +244,25 @@ namespace SqlSugar return GetEntityList(Context, dataReader); } } + public virtual Task> DataReaderToListNoUsingAsync(Type type, IDataReader dataReader) + { + if (type.Name.Contains("KeyValuePair")) + { + return GetKeyValueListAsync(type, dataReader); + } + else if (type.IsValueType() || type == UtilConstants.StringType || type == UtilConstants.ByteArrayType) + { + return GetValueTypeListAsync(type, dataReader); + } + else if (type.IsArray) + { + return GetArrayListAsync(type, dataReader); + } + else + { + return GetEntityListAsync(Context, dataReader); + } + } #endregion #region Throw rule diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DeleteProvider/DeleteableProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DeleteProvider/DeleteableProvider.cs index 2c6c66abe..823cd8cc1 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DeleteProvider/DeleteableProvider.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DeleteProvider/DeleteableProvider.cs @@ -29,35 +29,36 @@ namespace SqlSugar return this.Context.EntityMaintenance.GetEntityInfo(); } } - public int ExecuteCommand() - { - DeleteBuilder.EntityInfo = this.Context.EntityMaintenance.GetEntityInfo(); - string sql = DeleteBuilder.ToSqlString(); - var paramters = DeleteBuilder.Parameters == null ? null : DeleteBuilder.Parameters.ToArray(); - RestoreMapping(); - AutoRemoveDataCache(); - Before(sql); - var result = Db.ExecuteCommand(sql, paramters); - After(sql); - return result; - } public void AddQueue() { var sqlObj = this.ToSql(); this.Context.Queues.Add(sqlObj.Key, sqlObj.Value); } + public int ExecuteCommand() + { + string sql; + SugarParameter[] paramters; + _ExecuteCommand(out sql, out paramters); + var result = Db.ExecuteCommand(sql, paramters); + After(sql); + return result; + } public bool ExecuteCommandHasChange() { return ExecuteCommand() > 0; } - public Task ExecuteCommandAsync() + public async Task ExecuteCommandAsync() { - return Task.FromResult(ExecuteCommand()); + string sql; + SugarParameter[] paramters; + _ExecuteCommand(out sql, out paramters); + var result =await Db.ExecuteCommandAsync(sql, paramters); + After(sql); + return result; } - - public Task ExecuteCommandHasChangeAsync() + public async Task ExecuteCommandHasChangeAsync() { - return Task.FromResult(ExecuteCommandHasChange()); + return await ExecuteCommandAsync() > 0; } public IDeleteable AS(string tableName) { @@ -325,6 +326,15 @@ namespace SqlSugar return this.EntityInfo.Columns.Where(it => it.IsPrimarykey).Select(it => it.DbColumnName).ToList(); } } + private void _ExecuteCommand(out string sql, out SugarParameter[] paramters) + { + DeleteBuilder.EntityInfo = this.Context.EntityMaintenance.GetEntityInfo(); + sql = DeleteBuilder.ToSqlString(); + paramters = DeleteBuilder.Parameters == null ? null : DeleteBuilder.Parameters.ToArray(); + RestoreMapping(); + AutoRemoveDataCache(); + Before(sql); + } protected virtual List GetIdentityKeys() { diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/InsertableProvider/InsertableProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/InsertableProvider/InsertableProvider.cs index 898a223bd..c9cf8fff2 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/InsertableProvider/InsertableProvider.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/InsertableProvider/InsertableProvider.cs @@ -44,31 +44,11 @@ namespace SqlSugar { return 0; } - if (InsertBuilder.DbColumnInfoList.HasValue()) - { - var pks = GetPrimaryKeys(); - foreach (var item in InsertBuilder.DbColumnInfoList) - { - var isPk = pks.Any(y => y.Equals(item.DbColumnName, StringComparison.CurrentCultureIgnoreCase)) || item.IsPrimarykey; - if (isPk && item.PropertyType == UtilConstants.GuidType && item.Value.ObjToString() == Guid.Empty.ToString()) - { - item.Value = Guid.NewGuid(); - if (InsertObjs.First().GetType().GetProperties().Any(it => it.Name == item.PropertyName)) - InsertObjs.First().GetType().GetProperties().First(it => it.Name == item.PropertyName).SetValue(InsertObjs.First(), item.Value, null); - } - } - } - InsertBuilder.IsReturnIdentity = false; - PreToSql(); - AutoRemoveDataCache(); - string sql = InsertBuilder.ToSqlString(); - RestoreMapping(); - Before(sql); + string sql = _ExecuteCommand(); var result = Ado.ExecuteCommand(sql, InsertBuilder.Parameters == null ? null : InsertBuilder.Parameters.ToArray()); After(sql, null); return result; } - public virtual KeyValuePair> ToSql() { InsertBuilder.IsReturnIdentity = true; @@ -84,32 +64,26 @@ namespace SqlSugar { return 0; } - InsertBuilder.IsReturnIdentity = true; - PreToSql(); - AutoRemoveDataCache(); - string sql = InsertBuilder.ToSqlString(); - RestoreMapping(); - Before(sql); + string sql = _ExecuteReturnIdentity(); var result = Ado.GetInt(sql, InsertBuilder.Parameters == null ? null : InsertBuilder.Parameters.ToArray()); After(sql, result); return result; } + public virtual long ExecuteReturnBigIdentity() { if (this.InsertObjs.Count() == 1 && this.InsertObjs.First() == null) { return 0; } - InsertBuilder.IsReturnIdentity = true; - PreToSql(); - AutoRemoveDataCache(); - string sql = InsertBuilder.ToSqlString(); - RestoreMapping(); - Before(sql); + string sql = _ExecuteReturnBigIdentity(); var result = Convert.ToInt64(Ado.GetScalar(sql, InsertBuilder.Parameters == null ? null : InsertBuilder.Parameters.ToArray())); After(sql, result); return result; } + + + public virtual T ExecuteReturnEntity() { ExecuteCommandIdentityIntoEntity(); @@ -131,25 +105,60 @@ namespace SqlSugar this.Context.EntityMaintenance.GetProperty(identityKey).SetValue(result, setValue, null); return idValue > 0; } - public Task ExecuteCommandAsync() + + public async Task ExecuteCommandAsync() { - return Task.FromResult(ExecuteCommand()); + if (this.InsertObjs.Count() == 1 && this.InsertObjs.First() == null) + { + return 0; + } + string sql = _ExecuteCommand(); + var result =await Ado.ExecuteCommandAsync(sql, InsertBuilder.Parameters == null ? null : InsertBuilder.Parameters.ToArray()); + After(sql, null); + return result; } - public Task ExecuteReturnIdentityAsync() + public async Task ExecuteReturnIdentityAsync() { - return Task.FromResult(ExecuteReturnIdentity()); + if (this.InsertObjs.Count() == 1 && this.InsertObjs.First() == null) + { + return 0; + } + string sql = _ExecuteReturnIdentity(); + var result =await Ado.GetIntAsync(sql, InsertBuilder.Parameters == null ? null : InsertBuilder.Parameters.ToArray()); + After(sql, result); + return result; } - public Task ExecuteReturnEntityAsync() + public async Task ExecuteReturnEntityAsync() { - return Task.FromResult(ExecuteReturnEntity()); + await ExecuteCommandIdentityIntoEntityAsync(); + return InsertObjs.First(); } - public Task ExecuteCommandIdentityIntoEntityAsync() + public async Task ExecuteCommandIdentityIntoEntityAsync() { - return Task.FromResult(ExecuteCommandIdentityIntoEntity()); + var result = InsertObjs.First(); + var identityKeys = GetIdentityKeys(); + if (identityKeys.Count == 0) { return await this.ExecuteCommandAsync() > 0; } + var idValue =await ExecuteReturnBigIdentityAsync(); + Check.Exception(identityKeys.Count > 1, "ExecuteCommandIdentityIntoEntity does not support multiple identity keys"); + var identityKey = identityKeys.First(); + object setValue = 0; + if (idValue > int.MaxValue) + setValue = idValue; + else + setValue = Convert.ToInt32(idValue); + this.Context.EntityMaintenance.GetProperty(identityKey).SetValue(result, setValue, null); + return idValue > 0; } - public Task ExecuteReturnBigIdentityAsync() + public async Task ExecuteReturnBigIdentityAsync() { - return Task.FromResult(ExecuteReturnBigIdentity()); + if (this.InsertObjs.Count() == 1 && this.InsertObjs.First() == null) + { + return 0; + } + string sql = _ExecuteReturnBigIdentity(); + var result = Convert.ToInt64(await Ado.GetScalarAsync(sql, InsertBuilder.Parameters == null ? null : InsertBuilder.Parameters.ToArray())); + After(sql, result); + return result; } #endregion @@ -230,6 +239,51 @@ namespace SqlSugar #endregion #region Protected Methods + private string _ExecuteReturnBigIdentity() + { + InsertBuilder.IsReturnIdentity = true; + PreToSql(); + AutoRemoveDataCache(); + string sql = InsertBuilder.ToSqlString(); + RestoreMapping(); + Before(sql); + return sql; + } + private string _ExecuteReturnIdentity() + { + InsertBuilder.IsReturnIdentity = true; + PreToSql(); + AutoRemoveDataCache(); + string sql = InsertBuilder.ToSqlString(); + RestoreMapping(); + Before(sql); + return sql; + } + + private string _ExecuteCommand() + { + if (InsertBuilder.DbColumnInfoList.HasValue()) + { + var pks = GetPrimaryKeys(); + foreach (var item in InsertBuilder.DbColumnInfoList) + { + var isPk = pks.Any(y => y.Equals(item.DbColumnName, StringComparison.CurrentCultureIgnoreCase)) || item.IsPrimarykey; + if (isPk && item.PropertyType == UtilConstants.GuidType && item.Value.ObjToString() == Guid.Empty.ToString()) + { + item.Value = Guid.NewGuid(); + if (InsertObjs.First().GetType().GetProperties().Any(it => it.Name == item.PropertyName)) + InsertObjs.First().GetType().GetProperties().First(it => it.Name == item.PropertyName).SetValue(InsertObjs.First(), item.Value, null); + } + } + } + InsertBuilder.IsReturnIdentity = false; + PreToSql(); + AutoRemoveDataCache(); + string sql = InsertBuilder.ToSqlString(); + RestoreMapping(); + Before(sql); + return sql; + } private void AutoRemoveDataCache() { var moreSetts = this.Context.CurrentConnectionConfig.MoreSettings; diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/QueryableProvider/QueryableProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/QueryableProvider/QueryableProvider.cs index 5cc2b7bc1..bba230aa8 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/QueryableProvider/QueryableProvider.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/QueryableProvider/QueryableProvider.cs @@ -16,7 +16,7 @@ namespace SqlSugar #region T1 public partial class QueryableProvider : QueryableAccessory, ISugarQueryable { - public ISqlSugarClient Context { get; set; } + public SqlSugarProvider Context { get; set; } public IAdo Db { get { return Context.Ado; } } public IDbBind Bind { get { return this.Db.DbBind; } } public ISqlBuilder SqlBuilder { get; set; } @@ -596,9 +596,9 @@ namespace SqlSugar } public virtual int Count() { - InitMapping(); - QueryBuilder.IsCount = true; - int result = 0; + MappingTableList expMapping; + int result; + _CountBegin(out expMapping, out result); if (IsCache) { var cacheService = this.Context.CurrentConnectionConfig.ConfigureExternalServices.DataInfoCacheService; @@ -608,8 +608,7 @@ namespace SqlSugar { result = GetCount(); } - RestoreMapping(); - QueryBuilder.IsCount = false; + _CountEnd(expMapping); return result; } @@ -753,18 +752,7 @@ namespace SqlSugar } public virtual List ToPageList(int pageIndex, int pageSize) { - if (pageIndex == 0) - pageIndex = 1; - if (QueryBuilder.PartitionByValue.HasValue()) - { - QueryBuilder.ExternalPageIndex = pageIndex; - QueryBuilder.ExternalPageSize = pageSize; - } - else - { - QueryBuilder.Skip = (pageIndex - 1) * pageSize; - QueryBuilder.Take = pageSize; - } + pageIndex = _PageList(pageIndex, pageSize); return ToList(); } public virtual List ToPageList(int pageIndex, int pageSize, ref int totalNumber) @@ -836,139 +824,262 @@ namespace SqlSugar return result; } #region Async methods - public Task SingleAsync() + public async Task SingleAsync() { - return Task.FromResult(Single()); + if (QueryBuilder.OrderByValue.IsNullOrEmpty()) + { + QueryBuilder.OrderByValue = QueryBuilder.DefaultOrderByTemplate; + } + var oldSkip = QueryBuilder.Skip; + var oldTake = QueryBuilder.Take; + var oldOrderBy = QueryBuilder.OrderByValue; + QueryBuilder.Skip = null; + QueryBuilder.Take = null; + QueryBuilder.OrderByValue = null; + var result =await this.ToListAsync(); + QueryBuilder.Skip = oldSkip; + QueryBuilder.Take = oldTake; + QueryBuilder.OrderByValue = oldOrderBy; + if (result == null || result.Count == 0) + { + return default(T); + } + else if (result.Count == 2) + { + Check.Exception(true, ".Single() result must not exceed one . You can use.First()"); + return default(T); + } + else + { + return result.SingleOrDefault(); + } } - public Task SingleAsync(Expression> expression) + public async Task SingleAsync(Expression> expression) { - return Task.FromResult(Single(expression)); + _Where(expression); + var result =await SingleAsync(); + this.QueryBuilder.WhereInfos.Remove(this.QueryBuilder.WhereInfos.Last()); + return result; } - public Task FirstAsync() + public async Task FirstAsync() { - return Task.FromResult(First()); + if (QueryBuilder.OrderByValue.IsNullOrEmpty()) + { + QueryBuilder.OrderByValue = QueryBuilder.DefaultOrderByTemplate; + } + if (QueryBuilder.Skip.HasValue) + { + QueryBuilder.Take = 1; + var list = await this.ToListAsync(); + return list.FirstOrDefault(); + } + else + { + QueryBuilder.Skip = 0; + QueryBuilder.Take = 1; + var result =await this.ToListAsync(); + if (result.HasValue()) + return result.FirstOrDefault(); + else + return default(T); + } } - public Task FirstAsync(Expression> expression) + public async Task FirstAsync(Expression> expression) { - return Task.FromResult(First(expression)); + _Where(expression); + var result = await FirstAsync(); + this.QueryBuilder.WhereInfos.Remove(this.QueryBuilder.WhereInfos.Last()); + return result; } - public Task AnyAsync(Expression> expression) + public async Task AnyAsync(Expression> expression) { - return Task.FromResult(Any(expression)); + _Where(expression); + var result =await AnyAsync(); + this.QueryBuilder.WhereInfos.Remove(this.QueryBuilder.WhereInfos.Last()); + return result; } - public Task AnyAsync() + public async Task AnyAsync() { - return Task.FromResult(Any()); + return await this.CountAsync() > 0; } - public Task CountAsync() + public async Task CountAsync() { - return Task.FromResult(Count()); + MappingTableList expMapping; + int result; + _CountBegin(out expMapping, out result); + if (IsCache) + { + var cacheService = this.Context.CurrentConnectionConfig.ConfigureExternalServices.DataInfoCacheService; + result = CacheSchemeMain.GetOrCreate(cacheService, this.QueryBuilder, () => { return GetCount(); }, CacheTime, this.Context); + } + else + { + result =await GetCountAsync(); + } + _CountEnd(expMapping); + return result; } - public Task CountAsync(Expression> expression) + public async Task CountAsync(Expression> expression) { - return Task.FromResult(Count(expression)); + _Where(expression); + var result =await CountAsync(); + this.QueryBuilder.WhereInfos.Remove(this.QueryBuilder.WhereInfos.Last()); + return result; } - public Task MaxAsync(string maxField) + public async Task MaxAsync(string maxField) { - return Task.FromResult(Max(maxField)); + this.Select(string.Format(QueryBuilder.MaxTemplate, maxField)); + var list = await this._ToListAsync(); + var result =list.SingleOrDefault(); + return result; } public Task MaxAsync(Expression> expression) { - return Task.FromResult(Max(expression)); + return _MaxAsync(expression); } - public Task MinAsync(string minField) + public async Task MinAsync(string minField) { - return Task.FromResult(Min(minField)); + this.Select(string.Format(QueryBuilder.MinTemplate, minField)); + var list = await this._ToListAsync(); + var result = list.SingleOrDefault(); + return result; } public Task MinAsync(Expression> expression) { - return Task.FromResult(Min(expression)); + return _MinAsync(expression); } - public Task SumAsync(string sumField) + public async Task SumAsync(string sumField) { - return Task.FromResult(Sum(sumField)); + this.Select(string.Format(QueryBuilder.SumTemplate, sumField)); + var list = await this._ToListAsync(); + var result = list.SingleOrDefault(); + return result; } public Task SumAsync(Expression> expression) { - return Task.FromResult(Sum(expression)); + return _SumAsync(expression); } - public Task AvgAsync(string avgField) + public async Task AvgAsync(string avgField) { - return Task.FromResult(Avg(avgField)); + this.Select(string.Format(QueryBuilder.AvgTemplate, avgField)); + var list = await this._ToListAsync(); + var result = list.SingleOrDefault(); + return result; } public Task AvgAsync(Expression> expression) { - return Task.FromResult(Avg(expression)); + return _AvgAsync(expression); } public Task> ToListAsync() { - return Task.FromResult(ToList()); + InitMapping(); + return _ToListAsync(); } - - public Task ToJsonAsync() - { - return Task.FromResult(ToJson()); - } - - public Task ToJsonPageAsync(int pageIndex, int pageSize) - { - return Task.FromResult(ToJsonPage(pageIndex, pageSize)); - } - - public Task ToJsonPageAsync(int pageIndex, int pageSize, ref int totalNumber) - { - return Task.FromResult(ToJsonPage(pageIndex, pageSize, ref totalNumber)); - } - - public Task ToDataTableAsync() - { - return Task.FromResult(ToDataTable()); - } - - public Task ToDataTablePageAsync(int pageIndex, int pageSize) - { - return Task.FromResult(ToDataTablePage(pageIndex, pageSize)); - } - - public Task ToDataTablePageAsync(int pageIndex, int pageSize, ref int totalNumber) - { - return Task.FromResult(ToDataTablePage(pageIndex, pageSize, ref totalNumber)); - } - public Task> ToPageListAsync(int pageIndex, int pageSize) { - return Task.FromResult(ToPageList(pageIndex, pageSize)); + pageIndex = _PageList(pageIndex, pageSize); + return ToListAsync(); + } + public async Task> ToPageListAsync(int pageIndex, int pageSize, RefAsync totalNumber) + { + totalNumber.Value = await this.Clone().CountAsync(); + return await this.Clone().ToPageListAsync(pageIndex, pageSize); + } + public async Task ToJsonAsync() + { + if (IsCache) + { + var cacheService = this.Context.CurrentConnectionConfig.ConfigureExternalServices.DataInfoCacheService; + var result = CacheSchemeMain.GetOrCreate(cacheService, this.QueryBuilder, () => + { + return this.Context.Utilities.SerializeObject(this.ToList(), typeof(T)); + }, CacheTime, this.Context); + return result; + } + else + { + return this.Context.Utilities.SerializeObject(await this.ToListAsync(), typeof(T)); + } + } + public async Task ToJsonPageAsync(int pageIndex, int pageSize) + { + return this.Context.Utilities.SerializeObject(await this.ToPageListAsync(pageIndex, pageSize), typeof(T)); + } + public async Task ToJsonPageAsync(int pageIndex, int pageSize, RefAsync totalNumber) + { + totalNumber.Value = await this.Clone().CountAsync(); + return await this.Clone().ToJsonPageAsync(pageIndex, pageSize); + } + public async Task ToDataTableAsync() + { + InitMapping(); + var sqlObj = this.ToSql(); + RestoreMapping(); + DataTable result = null; + if (IsCache) + { + var cacheService = this.Context.CurrentConnectionConfig.ConfigureExternalServices.DataInfoCacheService; + result = CacheSchemeMain.GetOrCreate(cacheService, this.QueryBuilder, () => { return this.Db.GetDataTable(sqlObj.Key, sqlObj.Value.ToArray()); }, CacheTime, this.Context); + } + else + { + result = await this.Db.GetDataTableAsync(sqlObj.Key, sqlObj.Value.ToArray()); + } + return result; + } + public Task ToDataTablePageAsync(int pageIndex, int pageSize) + { + pageIndex = _PageList(pageIndex, pageSize); + return ToDataTableAsync(); + } + public async Task ToDataTablePageAsync(int pageIndex, int pageSize, RefAsync totalNumber) + { + totalNumber.Value = await this.Clone().CountAsync(); + return await this.Clone().ToDataTablePageAsync(pageIndex, pageSize); } - public Task> ToPageListAsync(int pageIndex, int pageSize, ref int totalNumber) - { - return Task.FromResult(ToPageList(pageIndex, pageSize, ref totalNumber)); - } #endregion #region Private Methods - //private void TaskStart(Task result) - //{ - // if (this.Context.CurrentConnectionConfig.IsShardSameThread) - // { - // Check.Exception(true, "IsShardSameThread=true can't be used async method"); - // } - // result.Start(); - //} + private void _CountEnd(MappingTableList expMapping) + { + RestoreMapping(); + QueryBuilder.IsCount = false; + if (expMapping.Count > 0) + { + if (this.QueryableMappingTableList == null) + { + this.QueryableMappingTableList = new MappingTableList(); + } + this.QueryableMappingTableList.Add(expMapping.First()); + } + } + + private void _CountBegin(out MappingTableList expMapping, out int result) + { + expMapping = new MappingTableList(); + if (QueryBuilder.EntityName == "ExpandoObject" && this.Context.MappingTables.Any(it => it.EntityName == "ExpandoObject")) + { + expMapping.Add("ExpandoObject", this.Context.MappingTables.First(it => it.EntityName == "ExpandoObject").DbTableName); + } + InitMapping(); + QueryBuilder.IsCount = true; + result = 0; + } protected ISugarQueryable _Select(Expression expression) { QueryBuilder.CheckExpression(expression, "Select"); @@ -1005,6 +1116,23 @@ namespace SqlSugar return this; } } + private int _PageList(int pageIndex, int pageSize) + { + if (pageIndex == 0) + pageIndex = 1; + if (QueryBuilder.PartitionByValue.HasValue()) + { + QueryBuilder.ExternalPageIndex = pageIndex; + QueryBuilder.ExternalPageSize = pageSize; + } + else + { + QueryBuilder.Skip = (pageIndex - 1) * pageSize; + QueryBuilder.Take = pageSize; + } + + return pageIndex; + } protected ISugarQueryable _GroupBy(Expression expression) { QueryBuilder.CheckExpression(expression, "GroupBy"); @@ -1035,6 +1163,15 @@ namespace SqlSugar QueryBuilder.SelectValue = null; return result; } + protected async Task _MinAsync(Expression expression) + { + QueryBuilder.CheckExpression(expression, "Main"); + var isSingle = QueryBuilder.IsSingle(); + var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple); + var result = await MinAsync(lamResult.GetResultString()); + QueryBuilder.SelectValue = null; + return result; + } protected TResult _Avg(Expression expression) { QueryBuilder.CheckExpression(expression, "Avg"); @@ -1042,6 +1179,13 @@ namespace SqlSugar var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple); return Avg(lamResult.GetResultString()); } + protected async Task _AvgAsync(Expression expression) + { + QueryBuilder.CheckExpression(expression, "Avg"); + var isSingle = QueryBuilder.IsSingle(); + var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple); + return await AvgAsync(lamResult.GetResultString()); + } protected TResult _Max(Expression expression) { QueryBuilder.CheckExpression(expression, "Max"); @@ -1051,6 +1195,15 @@ namespace SqlSugar QueryBuilder.SelectValue = null; return reslut; } + protected async Task _MaxAsync(Expression expression) + { + QueryBuilder.CheckExpression(expression, "Max"); + var isSingle = QueryBuilder.IsSingle(); + var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple); + var reslut =await MaxAsync(lamResult.GetResultString()); + QueryBuilder.SelectValue = null; + return reslut; + } protected TResult _Sum(Expression expression) { QueryBuilder.CheckExpression(expression, "Sum"); @@ -1060,6 +1213,15 @@ namespace SqlSugar QueryBuilder.SelectValue = null; return reslut; } + protected async Task _SumAsync(Expression expression) + { + QueryBuilder.CheckExpression(expression, "Sum"); + var isSingle = QueryBuilder.IsSingle(); + var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple); + var reslut =await SumAsync(lamResult.GetResultString()); + QueryBuilder.SelectValue = null; + return reslut; + } protected ISugarQueryable _As(string tableName, string entityName) { IsAs = true; @@ -1132,6 +1294,23 @@ namespace SqlSugar _Mapper(result); return result; } + protected async Task> _ToListAsync() + { + List result = null; + var sqlObj = this.ToSql(); + if (IsCache) + { + var cacheService = this.Context.CurrentConnectionConfig.ConfigureExternalServices.DataInfoCacheService; + result = CacheSchemeMain.GetOrCreate>(cacheService, this.QueryBuilder, () => { return GetData(sqlObj); }, CacheTime, this.Context); + } + else + { + result =await GetDataAsync(sqlObj); + } + RestoreMapping(); + _Mapper(result); + return result; + } protected void _Mapper(List result) { @@ -1519,6 +1698,15 @@ namespace SqlSugar var result = Context.Ado.GetInt(sql, QueryBuilder.Parameters.ToArray()); return result; } + protected async Task GetCountAsync() + { + var sql = string.Empty; + ToSqlBefore(); + sql = QueryBuilder.ToSqlString(); + sql = QueryBuilder.ToCountSql(sql); + var result =Convert.ToInt32(await Context.Ado.GetScalarAsync(sql, QueryBuilder.Parameters.ToArray())); + return result; + } private void ToSqlBefore() { @@ -1535,6 +1723,22 @@ namespace SqlSugar var isComplexModel = QueryBuilder.IsComplexModel(sqlObj.Key); var entityType = typeof(TResult); var dataReader = this.Db.GetDataReader(sqlObj.Key, sqlObj.Value.ToArray()); + result = GetData(isComplexModel, entityType, dataReader); + return result; + } + protected async Task> GetDataAsync(KeyValuePair> sqlObj) + { + List result; + var isComplexModel = QueryBuilder.IsComplexModel(sqlObj.Key); + var entityType = typeof(TResult); + var dataReader = await this.Db.GetDataReaderAsync(sqlObj.Key, sqlObj.Value.ToArray()); + result =await GetDataAsync(isComplexModel, entityType, dataReader); + return result; + } + + private List GetData(bool isComplexModel, Type entityType, IDataReader dataReader) + { + List result; if (entityType == UtilConstants.DynamicType) { result = this.Context.Utilities.DataReaderToExpandoObjectList(dataReader) as List; @@ -1554,6 +1758,29 @@ namespace SqlSugar SetContextModel(result, entityType); return result; } + private async Task> GetDataAsync(bool isComplexModel, Type entityType, IDataReader dataReader) + { + List result; + if (entityType == UtilConstants.DynamicType) + { + result =await this.Context.Utilities.DataReaderToExpandoObjectListAsync(dataReader) as List; + } + else if (entityType == UtilConstants.ObjType) + { + var expObj = await this.Context.Utilities.DataReaderToExpandoObjectListAsync(dataReader); + result = expObj.Select(it => ((TResult)(object)it)).ToList(); + } + else if (entityType.IsAnonymousType() || isComplexModel) + { + result =await this.Context.Utilities.DataReaderToListAsync(dataReader); + } + else + { + result =await this.Bind.DataReaderToListAsync(entityType, dataReader); + } + SetContextModel(result, entityType); + return result; + } protected void _InQueryable(Expression expression, KeyValuePair> sqlObj) { @@ -1618,6 +1845,7 @@ namespace SqlSugar { var contextProperty = item.GetType().GetProperty("Context"); SqlSugarProvider newClient = this.Context.Utilities.CopyContext(); + newClient.Ado.IsDisableMasterSlaveSeparation = true; if (newClient.CurrentConnectionConfig.AopEvents == null) newClient.CurrentConnectionConfig.AopEvents = new AopEvents(); contextProperty.SetValue(item, newClient, null); @@ -1625,23 +1853,6 @@ namespace SqlSugar } } } - //protected ISugarQueryable CopyQueryable() - //{ - // var asyncContext = this.Context.Utilities.CopyContext(true); - // asyncContext.IsAsyncMethod = true; - // asyncContext.CurrentConnectionConfig.IsAutoCloseConnection = true; - // var asyncQueryable = asyncContext.Queryable().Select(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)!=null)) - // { - // (asyncQueryable as QueryableProvider).Mappers = this.Mappers; - // } - // CopyQueryBuilder(asyncQueryable.QueryBuilder); return asyncQueryable; - //} - protected void CopyQueryBuilder(QueryBuilder asyncQueryableBuilder) { var pars = new List(); diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SugarProvider/SqlSugarAccessory.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SugarProvider/SqlSugarAccessory.cs index d2433b275..36cc16112 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SugarProvider/SqlSugarAccessory.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SugarProvider/SqlSugarAccessory.cs @@ -10,7 +10,7 @@ namespace SqlSugar public partial class SqlSugarProvider { #region Properties - public ISqlSugarClient Context + public SqlSugarProvider Context { get { @@ -39,7 +39,7 @@ namespace SqlSugar public Dictionary _TempItems; public QueueList _Queues; protected ISqlBuilder _SqlBuilder; - protected ISqlSugarClient _Context { get; set; } + protected SqlSugarProvider _Context { get; set; } protected EntityMaintenance _EntityProvider; protected IAdo _Ado; protected ILambdaExpressions _LambdaExpressions; diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SugarProvider/SqlSugarProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SugarProvider/SqlSugarProvider.cs index 47a652d99..ba6a13695 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SugarProvider/SqlSugarProvider.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SugarProvider/SqlSugarProvider.cs @@ -794,73 +794,65 @@ namespace SqlSugar return SaveQueuesProvider(isTran, (sql, parameters) => { return this.Ado.ExecuteCommand(sql, parameters); }); } - public Task SaveQueuesAsync(bool isTran = true) + public async Task SaveQueuesAsync(bool isTran = true) { - var result =Task.FromResult(SaveQueues(isTran)); - return result; + return await SaveQueuesProviderAsync(isTran, (sql, parameters) => { return this.Ado.ExecuteCommandAsync(sql, parameters); }); } public List SaveQueues(bool isTran = true) { return SaveQueuesProvider(isTran, (sql, parameters) => { return this.Ado.SqlQuery(sql, parameters); }); } - public Task> SaveQueuesAsync(bool isTran = true) + public async Task> SaveQueuesAsync(bool isTran = true) { - var result = Task.FromResult(SaveQueues(isTran)); - return result; + return await SaveQueuesProviderAsync(isTran, (sql, parameters) => { return this.Ado.SqlQueryAsync(sql, parameters); }); } public Tuple, List> SaveQueues(bool isTran = true) { return SaveQueuesProvider(isTran, (sql, parameters) => { return this.Ado.SqlQuery(sql, parameters); }); } - public Task, List>> SaveQueuesAsync(bool isTran = true) + public async Task, List>> SaveQueuesAsync(bool isTran = true) { - var result = Task.FromResult(SaveQueues(isTran)); - return result; + return await SaveQueuesProviderAsync(isTran, (sql, parameters) => { return this.Ado.SqlQueryAsync(sql, parameters); }); } public Tuple, List, List> SaveQueues(bool isTran = true) { return SaveQueuesProvider(isTran, (sql, parameters) => { return this.Ado.SqlQuery(sql, parameters); }); } - public Task, List, List>> SaveQueuesAsync(bool isTran = true) + public async Task, List, List>> SaveQueuesAsync(bool isTran = true) { - var result = Task.FromResult(SaveQueues(isTran)); - return result; + return await SaveQueuesProviderAsync(isTran, (sql, parameters) => { return this.Ado.SqlQueryAsync(sql, parameters); }); } public Tuple, List, List, List> SaveQueues(bool isTran = true) { return SaveQueuesProvider(isTran, (sql, parameters) => { return this.Ado.SqlQuery(sql, parameters); }); } - public Task, List, List, List>> SaveQueuesAsync(bool isTran = true) + public async Task, List, List, List>> SaveQueuesAsync(bool isTran = true) { - var result = Task.FromResult(SaveQueues(isTran)); - return result; + return await SaveQueuesProviderAsync(isTran, (sql, parameters) => { return this.Ado.SqlQueryAsync(sql, parameters); }); } public Tuple, List, List, List, List> SaveQueues(bool isTran = true) { return SaveQueuesProvider(isTran, (sql, parameters) => { return this.Ado.SqlQuery(sql, parameters); }); } - public Task, List, List, List, List>> SaveQueuesAsync(bool isTran = true) + public async Task, List, List, List, List>> SaveQueuesAsync(bool isTran = true) { - var result = Task.FromResult(SaveQueues(isTran)); - return result; + return await SaveQueuesProviderAsync(isTran, (sql, parameters) => { return this.Ado.SqlQueryAsync(sql, parameters); }); } public Tuple, List, List, List, List, List> SaveQueues(bool isTran = true) { return SaveQueuesProvider(isTran, (sql, parameters) => { return this.Ado.SqlQuery(sql, parameters); }); } - public Task, List, List, List, List, List>> SaveQueuesAsync(bool isTran = true) + public async Task, List, List, List, List, List>> SaveQueuesAsync(bool isTran = true) { - var result = Task.FromResult(SaveQueues(isTran)); - return result; + return await SaveQueuesProviderAsync(isTran, (sql, parameters) => { return this.Ado.SqlQueryAsync(sql, parameters); }); } public Tuple, List, List, List, List, List, List> SaveQueues(bool isTran = true) { return SaveQueuesProvider(isTran, (sql, parameters) => { return this.Ado.SqlQuery(sql, parameters); }); } - public Task, List, List, List, List, List, List>> SaveQueuesAsync(bool isTran = true) + public async Task, List, List, List, List, List, List>> SaveQueuesAsync(bool isTran = true) { - var result = Task.FromResult(SaveQueues(isTran)); - return result; + return await SaveQueuesProviderAsync(isTran, (sql, parameters) => { return this.Ado.SqlQueryAsync(sql, parameters); }); } public void AddQueue(string sql, object parsmeters=null) { @@ -888,6 +880,58 @@ namespace SqlSugar } public QueueList Queues { get { if (_Queues == null) { _Queues = new QueueList(); } return _Queues; } set => _Queues = value; } + + + private async Task SaveQueuesProviderAsync(bool isTran, Func, Task> func) + { + try + { + if (this.CurrentConnectionConfig.DbType == DbType.Oracle) + { + throw new Exception("Oracle no support SaveQueues"); + } + if (this.Queues == null || this.Queues.Count == 0) return default(T); + isTran = isTran && this.Ado.Transaction == null; + if (isTran) this.Ado.BeginTran(); + StringBuilder sqlBuilder = new StringBuilder(); + var parsmeters = new List(); + var index = 1; + if (this.Queues.HasValue()) + { + foreach (var item in Queues) + { + if (item.Sql == null) + item.Sql = string.Empty; + if (item.Parameters == null) + item.Parameters = new SugarParameter[] { }; + var itemParsmeters = item.Parameters.OrderByDescending(it => it.ParameterName.Length).ToList(); + List addParameters = new List(); + var itemSql = item.Sql; + foreach (var itemParameter in itemParsmeters) + { + var newName = itemParameter.ParameterName + "_q_" + index; + SugarParameter parameter = new SugarParameter(newName, itemParameter.Value); + parameter.DbType = itemParameter.DbType; + itemSql = UtilMethods.ReplaceSqlParameter(itemSql, itemParameter, newName); + addParameters.Add(parameter); + } + parsmeters.AddRange(addParameters); + itemSql = itemSql.TrimEnd(';') + ";"; + sqlBuilder.AppendLine(itemSql); + index++; + } + } + this.Queues.Clear(); + var result =await func(sqlBuilder.ToString(), parsmeters); + if (isTran) this.Ado.CommitTran(); + return result; + } + catch (Exception ex) + { + if (isTran) this.Ado.RollbackTran(); + throw ex; + } + } private T SaveQueuesProvider(bool isTran, Func, T> func) { try diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/UpdateProvider/UpdateableProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/UpdateProvider/UpdateableProvider.cs index 5012409c2..13efe5f74 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/UpdateProvider/UpdateableProvider.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/UpdateProvider/UpdateableProvider.cs @@ -51,29 +51,25 @@ namespace SqlSugar } public virtual int ExecuteCommand() { - PreToSql(); - AutoRemoveDataCache(); - Check.Exception(UpdateBuilder.WhereValues.IsNullOrEmpty() && GetPrimaryKeys().IsNullOrEmpty(), "You cannot have no primary key and no conditions"); - string sql = UpdateBuilder.ToSqlString(); - ValidateVersion(); - RestoreMapping(); - Before(sql); + string sql = _ExecuteCommand(); var result = this.Ado.ExecuteCommand(sql, UpdateBuilder.Parameters == null ? null : UpdateBuilder.Parameters.ToArray()); After(sql); return result; } - public bool ExecuteCommandHasChange() { return this.ExecuteCommand() > 0; } - public Task ExecuteCommandAsync() + public async Task ExecuteCommandAsync() { - return Task.FromResult(ExecuteCommand()); + string sql = _ExecuteCommand(); + var result =await this.Ado.ExecuteCommandAsync(sql, UpdateBuilder.Parameters == null ? null : UpdateBuilder.Parameters.ToArray()); + After(sql); + return result; } - public Task ExecuteCommandHasChangeAsync() + public async Task ExecuteCommandHasChangeAsync() { - return Task.FromResult(ExecuteCommandHasChange()); + return await this.ExecuteCommandAsync() > 0; } #endregion @@ -195,7 +191,6 @@ namespace SqlSugar } - public IUpdateable UpdateColumns(Expression> columns) { var updateColumns = UpdateBuilder.GetExpressionValue(columns, ResolveExpressType.ArraySingle).GetResultArray().Select(it => this.SqlBuilder.GetNoTranslationColumnName(it)).ToList(); @@ -374,6 +369,17 @@ namespace SqlSugar #endregion #region Helper + private string _ExecuteCommand() + { + PreToSql(); + AutoRemoveDataCache(); + Check.Exception(UpdateBuilder.WhereValues.IsNullOrEmpty() && GetPrimaryKeys().IsNullOrEmpty(), "You cannot have no primary key and no conditions"); + string sql = UpdateBuilder.ToSqlString(); + ValidateVersion(); + RestoreMapping(); + Before(sql); + return sql; + } private void AutoRemoveDataCache() { var moreSetts = this.Context.CurrentConnectionConfig.MoreSettings; @@ -591,43 +597,7 @@ namespace SqlSugar this.Context.MappingTables = OldMappingTableList; } } - //private void TaskStart(Task result) - //{ - // if (this.Context.CurrentConnectionConfig.IsShardSameThread) - // { - // Check.Exception(true, "IsShardSameThread=true can't be used async method"); - // } - // result.Start(); - //} - //private IUpdateable CopyUpdateable() - //{ - // var asyncContext = this.Context.Utilities.CopyContext(true); - // asyncContext.CurrentConnectionConfig.IsAutoCloseConnection = true; - // asyncContext.IsAsyncMethod = true; - - // var asyncUpdateable = asyncContext.Updateable(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).WhereColumnList = this.WhereColumnList; - // (asyncUpdateable as UpdateableProvider).IsWhereColumns = this.IsWhereColumns; - // } - // if (this.RemoveCacheFunc != null) - // { - // asyncUpdateable.RemoveDataCache(); - // } - // return asyncUpdateable; - //} + private void ValidateVersion() { diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/CacheScheme/CacheKeyBuider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/CacheScheme/CacheKeyBuider.cs index 52ff7a8a2..856a06863 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/CacheScheme/CacheKeyBuider.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/CacheScheme/CacheKeyBuider.cs @@ -7,7 +7,7 @@ namespace SqlSugar { internal class CacheKeyBuider { - public static CacheKey GetKey(ISqlSugarClient context, QueryBuilder queryBuilder) + public static CacheKey GetKey(SqlSugarProvider context, QueryBuilder queryBuilder) { CacheKey result = new CacheKey(); result.Database = context.Context.Ado.Connection.Database; diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/CacheScheme/CacheSchemeMain.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/CacheScheme/CacheSchemeMain.cs index 5e5d9de6f..edec0a6e2 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/CacheScheme/CacheSchemeMain.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/CacheScheme/CacheSchemeMain.cs @@ -7,7 +7,7 @@ namespace SqlSugar { internal class CacheSchemeMain { - public static T GetOrCreate(ICacheService cacheService, QueryBuilder queryBuilder, Func getData, int cacheDurationInSeconds, ISqlSugarClient context) + public static T GetOrCreate(ICacheService cacheService, QueryBuilder queryBuilder, Func getData, int cacheDurationInSeconds, SqlSugarProvider context) { CacheKey key = CacheKeyBuider.GetKey(context, queryBuilder); string keyString = key.ToString(); diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Entities/AsyncRef.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Entities/AsyncRef.cs new file mode 100644 index 000000000..e50ab6d37 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Entities/AsyncRef.cs @@ -0,0 +1,22 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar +{ + public class RefAsync + { + public RefAsync() { } + public RefAsync(T value) { Value = value; } + public T Value { get; set; } + public override string ToString() + { + T value = Value; + return value == null ? "" : value.ToString(); + } + public static implicit operator T(RefAsync r) { return r.Value; } + public static implicit operator RefAsync(T value) { return new RefAsync(value); } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Entities/SugarTerant.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Entities/SugarTerant.cs index 22b4804f5..bfa6351a3 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Entities/SugarTerant.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Entities/SugarTerant.cs @@ -7,7 +7,7 @@ namespace SqlSugar { public class SugarTenant { - public ISqlSugarClient Context { get; set; } + public SqlSugarProvider Context { get; set; } public ConnectionConfig ConnectionConfig { get; set; } } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/ContextMethods.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/ContextMethods.cs index 25bc85c01..5892d3fd9 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/ContextMethods.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/ContextMethods.cs @@ -2,6 +2,7 @@ using System.Collections; using System.Collections.Generic; using System.Data; +using System.Data.Common; using System.Dynamic; using System.Linq; using System.Reflection; @@ -60,6 +61,64 @@ namespace SqlSugar return result; } } + /// + ///DataReader to Dynamic List + /// + /// + /// + public async Task> DataReaderToExpandoObjectListAsync(IDataReader reader) + { + using (reader) + { + List result = new List(); + if (reader != null && !reader.IsClosed) + { + while (await((DbDataReader)reader).ReadAsync()) + { + result.Add(DataReaderToExpandoObject(reader)); + } + } + return result; + } + } + + + /// + ///DataReader to Dynamic List + /// + /// + /// + public List DataReaderToExpandoObjectListNoUsing(IDataReader reader) + { + List result = new List(); + if (reader != null && !reader.IsClosed) + { + while (reader.Read()) + { + result.Add(DataReaderToExpandoObject(reader)); + } + } + return result; + } + + /// + ///DataReader to Dynamic List + /// + /// + /// + public async Task> DataReaderToExpandoObjectListAsyncNoUsing(IDataReader reader) + { + List result = new List(); + if (reader != null && !reader.IsClosed) + { + while (await ((DbDataReader)reader).ReadAsync()) + { + result.Add(DataReaderToExpandoObject(reader)); + } + } + return result; + } + /// ///DataReader to DataReaderToDictionary @@ -130,52 +189,7 @@ namespace SqlSugar { while (reader.Read()) { - var readerValues = DataReaderToDictionary(reader, tType); - var result = new Dictionary(); - foreach (var item in classProperties) - { - var name = item.Name; - var typeName = tType.Name; - if (item.PropertyType.IsClass()) - { - result.Add(name, DataReaderToDynamicList_Part(readerValues, item, reval)); - } - else - { - if (readerValues.Any(it => it.Key.Equals(name, StringComparison.CurrentCultureIgnoreCase))) - { - var addValue = readerValues.ContainsKey(name) ? readerValues[name] : readerValues.First(it => it.Key.Equals(name, StringComparison.CurrentCultureIgnoreCase)).Value; - if (addValue == DBNull.Value || addValue == null) - { - if (item.PropertyType.IsIn(UtilConstants.IntType, UtilConstants.DecType, UtilConstants.DobType, UtilConstants.ByteType)) - { - addValue = 0; - } - else if (item.PropertyType == UtilConstants.GuidType) - { - addValue = Guid.Empty; - } - else if (item.PropertyType == UtilConstants.DateType) - { - addValue = DateTime.MinValue; - } - else if (item.PropertyType == UtilConstants.StringType) - { - addValue = null; - } - else - { - addValue = null; - } - } - else if (item.PropertyType == UtilConstants.IntType) - { - addValue = Convert.ToInt32(addValue); - } - result.Add(name, addValue); - } - } - } + Dictionary result = DataReaderToList(reader, tType, classProperties, reval); var stringValue = SerializeObject(result); reval.Add((T)DeserializeObject(stringValue)); } @@ -183,6 +197,127 @@ namespace SqlSugar return reval; } } + /// + /// DataReaderToList + /// + /// + /// + /// + public List DataReaderToListNoUsing(IDataReader reader) + { + var tType = typeof(T); + var classProperties = tType.GetProperties().ToList(); + var reval = new List(); + if (reader != null && !reader.IsClosed) + { + while (reader.Read()) + { + Dictionary result = DataReaderToList(reader, tType, classProperties, reval); + var stringValue = SerializeObject(result); + reval.Add((T)DeserializeObject(stringValue)); + } + } + return reval; + } + /// + /// DataReaderToList + /// + /// + /// + /// + public async Task> DataReaderToListAsync(IDataReader reader) + { + using (reader) + { + var tType = typeof(T); + var classProperties = tType.GetProperties().ToList(); + var reval = new List(); + if (reader != null && !reader.IsClosed) + { + while (await ((DbDataReader)reader).ReadAsync()) + { + Dictionary result = DataReaderToList(reader, tType, classProperties, reval); + var stringValue = SerializeObject(result); + reval.Add((T)DeserializeObject(stringValue)); + } + } + return reval; + } + } + /// + /// DataReaderToList + /// + /// + /// + /// + public async Task> DataReaderToListAsyncNoUsing(IDataReader reader) + { + var tType = typeof(T); + var classProperties = tType.GetProperties().ToList(); + var reval = new List(); + if (reader != null && !reader.IsClosed) + { + while (await ((DbDataReader)reader).ReadAsync()) + { + Dictionary result = DataReaderToList(reader, tType, classProperties, reval); + var stringValue = SerializeObject(result); + reval.Add((T)DeserializeObject(stringValue)); + } + } + return reval; + } + + private Dictionary DataReaderToList(IDataReader reader, Type tType, List classProperties, List reval) + { + var readerValues = DataReaderToDictionary(reader, tType); + var result = new Dictionary(); + foreach (var item in classProperties) + { + var name = item.Name; + var typeName = tType.Name; + if (item.PropertyType.IsClass()) + { + result.Add(name, DataReaderToDynamicList_Part(readerValues, item, reval)); + } + else + { + if (readerValues.Any(it => it.Key.Equals(name, StringComparison.CurrentCultureIgnoreCase))) + { + var addValue = readerValues.ContainsKey(name) ? readerValues[name] : readerValues.First(it => it.Key.Equals(name, StringComparison.CurrentCultureIgnoreCase)).Value; + if (addValue == DBNull.Value || addValue == null) + { + if (item.PropertyType.IsIn(UtilConstants.IntType, UtilConstants.DecType, UtilConstants.DobType, UtilConstants.ByteType)) + { + addValue = 0; + } + else if (item.PropertyType == UtilConstants.GuidType) + { + addValue = Guid.Empty; + } + else if (item.PropertyType == UtilConstants.DateType) + { + addValue = DateTime.MinValue; + } + else if (item.PropertyType == UtilConstants.StringType) + { + addValue = null; + } + else + { + addValue = null; + } + } + else if (item.PropertyType == UtilConstants.IntType) + { + addValue = Convert.ToInt32(addValue); + } + result.Add(name, addValue); + } + } + } + + return result; + } private Dictionary DataReaderToDynamicList_Part(Dictionary readerValues, PropertyInfo item, List reval) { diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IAdo.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IAdo.cs index 250fb89a2..cfc13abcf 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IAdo.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IAdo.cs @@ -33,38 +33,100 @@ namespace SqlSugar void SetCommandToAdapter(IDataAdapter adapter, DbCommand command); IDataAdapter GetAdapter(); DbCommand GetCommand(string sql, SugarParameter[] parameters); + + DataTable GetDataTable(string sql, object parameters); DataTable GetDataTable(string sql, params SugarParameter[] parameters); DataTable GetDataTable(string sql, List parameters); + + Task GetDataTableAsync(string sql, object parameters); + Task GetDataTableAsync(string sql, params SugarParameter[] parameters); + Task GetDataTableAsync(string sql, List parameters); + DataSet GetDataSetAll(string sql, object parameters); DataSet GetDataSetAll(string sql, params SugarParameter[] parameters); DataSet GetDataSetAll(string sql, List parameters); + + Task GetDataSetAllAsync(string sql, object parameters); + Task GetDataSetAllAsync(string sql, params SugarParameter[] parameters); + Task GetDataSetAllAsync(string sql, List parameters); + IDataReader GetDataReader(string sql, object parameters); IDataReader GetDataReader(string sql, params SugarParameter[] parameters); IDataReader GetDataReader(string sql, List parameters); + + + Task GetDataReaderAsync(string sql, object parameters); + Task GetDataReaderAsync(string sql, params SugarParameter[] parameters); + Task GetDataReaderAsync(string sql, List parameters); + Task GetDataReaderNoCloseAsync(string sql, params SugarParameter[] parameters); + object GetScalar(string sql, object parameters); object GetScalar(string sql, params SugarParameter[] parameters); object GetScalar(string sql, List parameters); + + Task GetScalarAsync(string sql, object parameters); + Task GetScalarAsync(string sql, params SugarParameter[] parameters); + Task GetScalarAsync(string sql, List parameters); + int ExecuteCommand(string sql, object parameters); int ExecuteCommand(string sql, params SugarParameter[] parameters); int ExecuteCommand(string sql, List parameters); + + Task ExecuteCommandAsync(string sql, params SugarParameter[] parameters); + Task ExecuteCommandAsync(string sql, object parameters); + Task ExecuteCommandAsync(string sql, List parameters); + string GetString(string sql, object parameters); string GetString(string sql, params SugarParameter[] parameters); string GetString(string sql, List parameters); + Task GetStringAsync(string sql, object parameters); + Task GetStringAsync(string sql, params SugarParameter[] parameters); + Task GetStringAsync(string sql, List parameters); + + int GetInt(string sql, object pars); int GetInt(string sql, params SugarParameter[] parameters); int GetInt(string sql, List parameters); - long GetLong(string sql, object pars); + + Task GetIntAsync(string sql, object pars); + Task GetIntAsync(string sql, params SugarParameter[] parameters); + Task GetIntAsync(string sql, List parameters); + + + long GetLong(string sql, object pars=null); + + Task GetLongAsync(string sql, object pars=null); + + Double GetDouble(string sql, object parameters); Double GetDouble(string sql, params SugarParameter[] parameters); Double GetDouble(string sql, List parameters); + + + Task GetDoubleAsync(string sql, object parameters); + Task GetDoubleAsync(string sql, params SugarParameter[] parameters); + Task GetDoubleAsync(string sql, List parameters); + + decimal GetDecimal(string sql, object parameters); decimal GetDecimal(string sql, params SugarParameter[] parameters); decimal GetDecimal(string sql, List parameters); + + Task GetDecimalAsync(string sql, object parameters); + Task GetDecimalAsync(string sql, params SugarParameter[] parameters); + Task GetDecimalAsync(string sql, List parameters); + + DateTime GetDateTime(string sql, object parameters); DateTime GetDateTime(string sql, params SugarParameter[] parameters); DateTime GetDateTime(string sql, List parameters); - List SqlQuery(string sql, object parameters = null); + + Task GetDateTimeAsync(string sql, object parameters); + Task GetDateTimeAsync(string sql, params SugarParameter[] parameters); + Task GetDateTimeAsync(string sql, List parameters); + + Tuple, List> SqlQuery(string sql, object parameters = null); Tuple, List, List> SqlQuery(string sql, object parameters = null); Tuple, List, List,List> SqlQuery(string sql, object parameters = null); @@ -72,14 +134,30 @@ namespace SqlSugar Tuple, List, List, List, List, List> SqlQuery(string sql, object parameters = null); Tuple, List, List, List, List, List, List> SqlQuery(string sql, object parameters = null); + Task, List>> SqlQueryAsync(string sql, object parameters = null); + Task, List, List>> SqlQueryAsync(string sql, object parameters = null); + Task, List, List, List>> SqlQueryAsync(string sql, object parameters = null); + Task, List, List, List, List>> SqlQueryAsync(string sql, object parameters = null); + Task, List, List, List, List, List>> SqlQueryAsync(string sql, object parameters = null); + Task, List, List, List, List, List, List>> SqlQueryAsync(string sql, object parameters = null); + + List SqlQuery(string sql, object parameters = null); List SqlQuery(string sql, params SugarParameter[] parameters); List SqlQuery(string sql, List parameters); + + Task> SqlQueryAsync(string sql, object parameters = null); + Task> SqlQueryAsync(string sql, List parameters); + Task> SqlQueryAsync(string sql, params SugarParameter[] parameters); + T SqlQuerySingle(string sql, object whereObj = null); T SqlQuerySingle(string sql, params SugarParameter[] parameters); T SqlQuerySingle(string sql, List parameters); - dynamic SqlQueryDynamic(string sql, object whereObj = null); - dynamic SqlQueryDynamic(string sql, params SugarParameter[] parameters); - dynamic SqlQueryDynamic(string sql, List parameters); + + Task SqlQuerySingleAsync(string sql, object whereObj = null); + Task SqlQuerySingleAsync(string sql, params SugarParameter[] parameters); + Task SqlQuerySingleAsync(string sql, List parameters); + + void Dispose(); void Close(); void Open(); @@ -96,9 +174,21 @@ namespace SqlSugar DbResult UseTran(Func action, Action errorCallBack = null); Task> UseTranAsync(Action action, Action errorCallBack = null); Task> UseTranAsync(Func action, Action errorCallBack = null); - - void UseStoredProcedure(Action action); - T UseStoredProcedure(Func action); IAdo UseStoredProcedure(); + + + + #region Obsolete + [Obsolete("Use db.ado.UseStoredProcedure().MethodName()")] + void UseStoredProcedure(Action action); + [Obsolete("Use db.ado.UseStoredProcedure().MethodName()")] + T UseStoredProcedure(Func action); + [Obsolete("Use SqlQuery(sql)")] + dynamic SqlQueryDynamic(string sql, object whereObj = null); + [Obsolete("Use SqlQuery(sql)")] + dynamic SqlQueryDynamic(string sql, params SugarParameter[] parameters); + [Obsolete("Use SqlQuery(sql)")] + dynamic SqlQueryDynamic(string sql, List parameters); + #endregion } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IContextMethods.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IContextMethods.cs index c821e782d..4cd026c86 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IContextMethods.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IContextMethods.cs @@ -13,7 +13,13 @@ namespace SqlSugar SqlSugarProvider Context { get; set; } ExpandoObject DataReaderToExpandoObject(IDataReader reader); List DataReaderToExpandoObjectList(IDataReader reader); + Task> DataReaderToExpandoObjectListAsync(IDataReader dataReader); + List DataReaderToExpandoObjectListNoUsing(IDataReader reader); + Task> DataReaderToExpandoObjectListAsyncNoUsing(IDataReader dataReader); List DataReaderToList(IDataReader reader); + List DataReaderToListNoUsing(IDataReader reader); + Task> DataReaderToListAsync(IDataReader dataReader); + Task> DataReaderToListAsyncNoUsing(IDataReader dataReader); string SerializeObject(object value); string SerializeObject(object value, Type type); T DeserializeObject(string value); @@ -27,6 +33,5 @@ namespace SqlSugar void RemoveCacheAll(); void RemoveCache(string key); void PageEach(IEnumerable pageItems, int pageSize, Action> action); - } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IDbBind.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IDbBind.cs index 4a95b26a5..14e99c092 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IDbBind.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IDbBind.cs @@ -3,6 +3,8 @@ using System.Collections.Generic; using System.Data; using System.Linq; using System.Text; +using System.Threading.Tasks; + namespace SqlSugar { public partial interface IDbBind @@ -21,6 +23,9 @@ namespace SqlSugar string GetCsharpTypeName(string dbTypeName); List> MappingTypes { get; } List DataReaderToList(Type type, IDataReader reader); + Task> DataReaderToListAsync(Type entityType, IDataReader dataReader); List DataReaderToListNoUsing(Type type, IDataReader reader); + Task> DataReaderToListNoUsingAsync(Type type, IDataReader reader); + } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IQueryable.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IQueryable.cs index 35f64c7df..1eb4c906c 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IQueryable.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IQueryable.cs @@ -11,7 +11,7 @@ namespace SqlSugar { public partial interface ISugarQueryable { - ISqlSugarClient Context { get; set; } + SqlSugarProvider Context { get; set; } ISqlBuilder SqlBuilder { get; set; } QueryBuilder QueryBuilder { get; set; } ISugarQueryable Clone(); @@ -129,7 +129,7 @@ namespace SqlSugar string ToJsonPage(int pageIndex, int pageSize); Task ToJsonPageAsync(int pageIndex, int pageSize); string ToJsonPage(int pageIndex, int pageSize, ref int totalNumber); - Task ToJsonPageAsync(int pageIndex, int pageSize,ref int totalNumber); + Task ToJsonPageAsync(int pageIndex, int pageSize, RefAsync totalNumber); KeyValuePair> ToSql(); @@ -139,13 +139,13 @@ namespace SqlSugar Task ToDataTablePageAsync(int pageIndex, int pageSize); DataTable ToDataTablePage(int pageIndex, int pageSize, ref int totalNumber); DataTable ToDataTablePage(int pageIndex, int pageSize, ref int totalNumber,ref int totalPage); - Task ToDataTablePageAsync(int pageIndex, int pageSize,ref int totalNumber); + Task ToDataTablePageAsync(int pageIndex, int pageSize, RefAsync totalNumber); List ToPageList(int pageIndex, int pageSize); Task> ToPageListAsync(int pageIndex, int pageSize); List ToPageList(int pageIndex, int pageSize, ref int totalNumber); List ToPageList(int pageIndex, int pageSize, ref int totalNumber,ref int totalPage); - Task> ToPageListAsync(int pageIndex, int pageSize,ref int totalNumber); + Task> ToPageListAsync(int pageIndex, int pageSize, RefAsync totalNumber); ISugarQueryable WithCache(int cacheDurationInSeconds = int.MaxValue); ISugarQueryable WithCacheIF(bool isCache, int cacheDurationInSeconds = int.MaxValue); string ToClassString(string className); diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/ISqlSugarClient.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/ISqlSugarClient.cs index 8f6a0fcae..4b550b646 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/ISqlSugarClient.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/ISqlSugarClient.cs @@ -23,7 +23,7 @@ namespace SqlSugar IAdo Ado { get; } AopProvider Aop { get; } ICodeFirst CodeFirst { get; } - ISqlSugarClient Context { get; set; } + IDbFirst DbFirst { get; } IDbMaintenance DbMaintenance { get; } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarClient.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarClient.cs index 8587b0c62..4e5167a42 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarClient.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarClient.cs @@ -12,7 +12,7 @@ namespace SqlSugar public partial class SqlSugarClient : ISqlSugarClient, ITenant { #region Gobal Property - private ISqlSugarClient _Context = null; + private SqlSugarProvider _Context = null; private string _ThreadId; private ConnectionConfig _CurrentConnectionConfig; private List _AllClients; @@ -45,7 +45,7 @@ namespace SqlSugar #endregion #region Global variable - public ISqlSugarClient Context { get => GetContext(); set => _Context = value; } + public SqlSugarProvider Context { get => GetContext(); } public bool IsSystemTablesConfig => this.Context.IsSystemTablesConfig; public ConnectionConfig CurrentConnectionConfig { get => _CurrentConnectionConfig; set => _CurrentConnectionConfig = value; } public Guid ContextID { get => this.Context.ContextID; set => this.Context.ContextID = value; } @@ -540,7 +540,7 @@ namespace SqlSugar InitTenant(_AllClients.First(it => it.ConnectionConfig.ConfigId == configId)); if (this._IsAllTran) this.Ado.BeginTran(); - if (this._IsOpen) + if (this._IsOpen) this.Open(); } public void ChangeDatabase(Func changeExpression) @@ -627,7 +627,7 @@ namespace SqlSugar public void RollbackTran() { this.Context.Ado.RollbackTran(); - AllClientEach(it=>it.Ado.RollbackTran()); + AllClientEach(it => it.Ado.RollbackTran()); _IsAllTran = false; } public void Close() @@ -669,76 +669,137 @@ namespace SqlSugar #endregion #region Helper - private ISqlSugarClient GetContext() + private SqlSugarProvider GetContext() { - if (CurrentConnectionConfig.IsShardSameThread) - { - ISqlSugarClient result = _Context; - if (CallContext.ContextList.Value.IsNullOrEmpty()) - { + if (IsSameThreadAndShard()) + return SameThreadAndShard(); + else if (IsNoSameThreadAndShard()) + return NoSameThreadAndShard(); + else if (IsSynchronization()) + return Synchronization(); + else + return NoSameThread(); + } - CallContext.ContextList.Value = new List(); - CallContext.ContextList.Value.Add(_Context); + private SqlSugarProvider NoSameThread() + { + if (CallContext.ContextList.Value == null) + { + var context = CopyClient(); + AddCallContext(context); + return context; + } + else + { + var result = GetCallContext(); + if (result == null) + { + var copy = CopyClient(); + AddCallContext(copy); + return copy; } else { - ISqlSugarClient cacheContext = GetCallContext(); - if (cacheContext != null) - { - result = cacheContext; - } - else - { - result = CopyClient(); - CallContext.ContextList.Value.Add(result); - } + return result; } - return result; } - else if (_ThreadId == Thread.CurrentThread.ManagedThreadId.ToString()) + } + + private SqlSugarProvider Synchronization() + { + _Context.MappingColumns = _MappingColumns; + _Context.MappingTables = _MappingTables; + _Context.IgnoreColumns = _IgnoreColumns; + _Context.IgnoreInsertColumns = _IgnoreInsertColumns; + return _Context; + } + + private SqlSugarProvider NoSameThreadAndShard() + { + if (CallContext.ContextList.Value.IsNullOrEmpty()) { - _Context.MappingColumns = _MappingColumns; - _Context.MappingTables = _MappingTables; - _Context.IgnoreColumns = _IgnoreColumns; - _Context.IgnoreInsertColumns = _IgnoreInsertColumns; + var copy = CopyClient(); + AddCallContext(copy); + return copy; + } + else + { + var result = GetCallContext(); + if (result == null) + { + var copy = CopyClient(); + AddCallContext(copy); + return copy; + } + else + { + return result; + } + } + } + + private SqlSugarProvider SameThreadAndShard() + { + if (CallContext.ContextList.Value.IsNullOrEmpty()) + { + AddCallContext(_Context); return _Context; } else { - if (CallContext.ContextList.Value == null) + var result = GetCallContext(); + if (result == null) { - CallContext.ContextList.Value = new List(); - } - if (CallContext.ContextList.Value.IsNullOrEmpty() || GetCallContext() == null) - { - var context = CopyClient(); - CallContext.ContextList.Value.Add(context); - return context; + var copy = CopyClient(); + AddCallContext(copy); + return copy; } else { - return GetCallContext(); + return result; } } } - private SqlSugarClient CopyClient() + + private bool IsSynchronization() { - var result = new SqlSugarClient(this.CurrentConnectionConfig); + return _ThreadId == Thread.CurrentThread.ManagedThreadId.ToString(); + } + + private bool IsNoSameThreadAndShard() + { + return CurrentConnectionConfig.IsShardSameThread && _ThreadId != Thread.CurrentThread.ManagedThreadId.ToString(); + } + + private bool IsSameThreadAndShard() + { + return CurrentConnectionConfig.IsShardSameThread && _ThreadId == Thread.CurrentThread.ManagedThreadId.ToString(); + } + + private SqlSugarProvider CopyClient() + { + var result = new SqlSugarProvider(this.CurrentConnectionConfig); result.MappingColumns = _MappingColumns; result.MappingTables = _MappingTables; result.IgnoreColumns = _IgnoreColumns; result.IgnoreInsertColumns = _IgnoreInsertColumns; - + return result; } - - private ISqlSugarClient GetCallContext() + private void AddCallContext(SqlSugarProvider context) { - return CallContext.ContextList.Value.FirstOrDefault(it => - it.CurrentConnectionConfig.DbType == _Context.CurrentConnectionConfig.DbType&& - it.CurrentConnectionConfig.ConnectionString == _Context.CurrentConnectionConfig.ConnectionString&& - it.CurrentConnectionConfig.InitKeyType==_Context.CurrentConnectionConfig.InitKeyType + CallContext.ContextList.Value = new List(); + CallContext.ContextList.Value.Add(context); + } + + private SqlSugarProvider GetCallContext() + { + return CallContext.ContextList.Value.FirstOrDefault(it => + it.CurrentConnectionConfig.DbType == _Context.CurrentConnectionConfig.DbType && + it.CurrentConnectionConfig.ConnectionString == _Context.CurrentConnectionConfig.ConnectionString && + it.CurrentConnectionConfig.InitKeyType == _Context.CurrentConnectionConfig.InitKeyType && + it.CurrentConnectionConfig.IsAutoCloseConnection == _Context.CurrentConnectionConfig.IsAutoCloseConnection ); } @@ -789,19 +850,11 @@ namespace SqlSugar { if (Tenant.Context == null) { - Tenant.Context = new SqlSugarClient(Tenant.ConnectionConfig); + Tenant.Context = new SqlSugarProvider(Tenant.ConnectionConfig); } _Context = Tenant.Context; this.CurrentConnectionConfig = Tenant.ConnectionConfig; } - //private void TaskStart(Task result) - //{ - // if (this.Context.CurrentConnectionConfig.IsShardSameThread) - // { - // Check.Exception(true, "IsShardSameThread=true can't be used async method"); - // } - // result.Start(); - //} #endregion #region Obsolete diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarForCore.nuspec b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarForCore.nuspec index 665ecdb02..7956b609f 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarForCore.nuspec +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarForCore.nuspec @@ -2,7 +2,7 @@ sqlSugarCore - 4.9.9.10 + 5.0 sunkaixuan Landa http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Utilities/CallContext.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Utilities/CallContext.cs index 4dc291c45..8cfb2d234 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Utilities/CallContext.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Utilities/CallContext.cs @@ -10,6 +10,6 @@ namespace SqlSugar { internal class CallContext { - public static ThreadLocal> ContextList = new ThreadLocal>(); + public static ThreadLocal> ContextList = new ThreadLocal>(); } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/DataBase/SqlSugar4xTest.sqlite b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/DataBase/SqlSugar4xTest.sqlite index f3b9da353..c7d4a4eba 100644 Binary files a/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/DataBase/SqlSugar4xTest.sqlite and b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/DataBase/SqlSugar4xTest.sqlite differ