From f96464aca664f2d1ecfe5cb9b49ed7465faffb6a Mon Sep 17 00:00:00 2001 From: sunkaixuna <610262374@qq.com> Date: Sun, 5 Sep 2021 02:55:08 +0800 Subject: [PATCH] Update core --- .../Abstract/AdoProvider/AdoProvider.cs | 50 +++++- .../EntityMaintenance/EntityMaintenance.cs | 11 ++ .../QueryableProvider/QueryableProvider.cs | 6 +- .../SqlBuilderProvider/QueryBuilder.cs | 2 +- .../SqlBuilderProvider/SqlBuilderProvider.cs | 2 +- .../SqlBuilderProvider/UpdateBuilder.cs | 4 +- .../SugarProvider/SqlSugarProvider.cs | 4 +- .../SqlSugar/Entities/SqlSguarTransaction.cs | 31 ++++ .../ExpressionsToSql/Common/SugarParameter.cs | 3 +- .../DbMethods/DefaultDbMethod.cs | 13 ++ .../ExpressionsToSql/DbMethods/IDbMethods.cs | 2 + .../ExpressionsToSql/DbMethods/SqlFunc.cs | 5 + .../ResolveItems/BaseResolve.cs | 85 ++++++++- .../MethodCallExpressionResolve.cs | 4 + .../SqlSugar/Infrastructure/ContextMethods.cs | 10 +- .../SqlSeverTest/SqlSugar/Interface/IAdo.cs | 4 +- .../SqlSugar/Interface/ITenant.cs | 1 + .../Dm/SqlBuilder/DmQueryBuilder.cs | 2 +- .../Dm/SqlBuilder/DmUpdateBuilder.cs | 7 +- .../MySql/SqlBuilder/MySqlQueryBuilder.cs | 2 +- .../Oracle/SqlBuilder/OracleQueryBuilder.cs | 2 +- .../CodeFirst/PostgreSQLCodeFirst.cs | 5 + .../PostgreSQL/DbBind/PostgreSQLDbBind.cs | 2 +- .../DbMaintenance/PostgreSQLDbMaintenance.cs | 4 + .../Insertable/PostgreSQLInserttable.cs | 8 +- .../SqlBuilder/PostgreSQLQueryBuilder.cs | 2 +- .../SqlServer/SqlBuilder/SqlServerBlukCopy.cs | 4 +- .../SqlServer/SqlServerProvider.cs | 8 +- .../Sqlite/SqlBuilder/SqliteQueryBuilder.cs | 2 +- .../SqlSeverTest/SqlSugar/SqlSugarClient.cs | 34 +++- .../SqlSeverTest/SqlSugar/SqlSugarScope.cs | 113 ++++++------ .../SqlSugar/Utilities/SugarRetry.cs | 166 ++++++++++++++++++ 32 files changed, 505 insertions(+), 93 deletions(-) create mode 100644 Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Entities/SqlSguarTransaction.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Utilities/SugarRetry.cs diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/AdoProvider/AdoProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/AdoProvider/AdoProvider.cs index aa5fb266f..5707e3974 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/AdoProvider/AdoProvider.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/AdoProvider/AdoProvider.cs @@ -101,7 +101,7 @@ namespace SqlSugar { if (this.Transaction != null) { - this.Transaction.Commit(); + this.Transaction.Rollback(); this.Transaction = null; } if (this.Connection != null && this.Connection.State != ConnectionState.Open) @@ -214,9 +214,29 @@ namespace SqlSugar return result; } - public Task> UseTranAsync(Action action, Action errorCallBack = null) + public async Task> UseTranAsync(Func action, Action errorCallBack = null) { - return Task.FromResult(UseTran(action, errorCallBack)); + var result = new DbResult(); + try + { + this.BeginTran(); + if (action != null) + await action(); + this.CommitTran(); + result.Data = result.IsSuccess = true; + } + catch (Exception ex) + { + result.ErrorException = ex; + result.ErrorMessage = ex.Message; + result.IsSuccess = false; + this.RollbackTran(); + if (errorCallBack != null) + { + errorCallBack(ex); + } + } + return result; } public DbResult UseTran(Func action, Action errorCallBack = null) @@ -244,9 +264,29 @@ namespace SqlSugar return result; } - public Task> UseTranAsync(Func action, Action errorCallBack = null) + public async Task> UseTranAsync(Func> action, Action errorCallBack = null) { - return Task.FromResult(UseTran(action, errorCallBack)); + var result = new DbResult(); + try + { + this.BeginTran(); + if (action != null) + result.Data = await action(); + this.CommitTran(); + result.IsSuccess = true; + } + catch (Exception ex) + { + result.ErrorException = ex; + result.ErrorMessage = ex.Message; + result.IsSuccess = false; + this.RollbackTran(); + if (errorCallBack != null) + { + errorCallBack(ex); + } + } + return result; } public IAdo UseStoredProcedure() diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/EntityMaintenance/EntityMaintenance.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/EntityMaintenance/EntityMaintenance.cs index 733114e27..538f39709 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/EntityMaintenance/EntityMaintenance.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/EntityMaintenance/EntityMaintenance.cs @@ -175,6 +175,17 @@ namespace SqlSugar } else { + if (sugarColumn.IsJson && String.IsNullOrEmpty(sugarColumn.ColumnDataType)) + { + if (this.Context.CurrentConnectionConfig.DbType == DbType.PostgreSQL) + { + column.DataType = "json"; + } + else + { + column.DataType = "varchar(4000)"; + } + } if (sugarColumn.IsIgnore == false) { column.DbColumnName = sugarColumn.ColumnName.IsNullOrEmpty() ? property.Name : sugarColumn.ColumnName; diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/QueryableProvider/QueryableProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/QueryableProvider/QueryableProvider.cs index ddc01aa4e..4e510ecc9 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/QueryableProvider/QueryableProvider.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/QueryableProvider/QueryableProvider.cs @@ -792,7 +792,7 @@ namespace SqlSugar Check.Exception(this.MapperAction != null || this.MapperActionWithCache != null, "'Mapper’ needs to be written after ‘MergeTable’ "); Check.Exception(this.QueryBuilder.SelectValue.IsNullOrEmpty(), "MergeTable need to use Queryable.Select Method ."); Check.Exception(this.QueryBuilder.Skip > 0 || this.QueryBuilder.Take > 0 || this.QueryBuilder.OrderByValue.HasValue(), "MergeTable Queryable cannot Take Skip OrderBy PageToList "); - var sqlobj = this.ToSql(); + var sqlobj = this._ToSql(); var index = QueryBuilder.WhereIndex + 1; var result = this.Context.Queryable().AS(SqlBuilder.GetPackTable(sqlobj.Key, "MergeTable")).AddParameters(sqlobj.Value).Select("*").With(SqlWith.Null); result.QueryBuilder.WhereIndex = index; @@ -1448,7 +1448,7 @@ namespace SqlSugar { QueryBuilder.ResultType = typeof(SugarCacheDataTable); InitMapping(); - var sqlObj = this.ToSql(); + var sqlObj = this._ToSql(); RestoreMapping(); DataTable result = null; if (IsCache) @@ -1821,7 +1821,7 @@ namespace SqlSugar protected async Task> _ToListAsync() { List result = null; - var sqlObj = this.ToSql(); + var sqlObj = this._ToSql(); if (IsCache) { var cacheService = this.Context.CurrentConnectionConfig.ConfigureExternalServices.DataInfoCacheService; diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/QueryBuilder.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/QueryBuilder.cs index 73b176c78..0a23aa8c5 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/QueryBuilder.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/QueryBuilder.cs @@ -474,7 +474,7 @@ namespace SqlSugar } public virtual bool IsComplexModel(string sql) { - return Regex.IsMatch(sql, @"AS \[\w+\.\w+\]"); + return Regex.IsMatch(sql, @"AS \[\w+\.\w+\]")|| Regex.IsMatch(sql, @"AS \[\w+\.\w+\.\w+\]"); } public string GetSqlQuerySql(string result) { diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/SqlBuilderProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/SqlBuilderProvider.cs index b7f800ad8..9d234e932 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/SqlBuilderProvider.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/SqlBuilderProvider.cs @@ -243,7 +243,7 @@ namespace SqlSugar parameters.Add(new SugarParameter(itemParameterName, "%" + val + "%")); i++; } - builder.Append($" ({string.Join(" OR ", sqls)}) "); + builder.Append($" {type} ({string.Join(" OR ", sqls)}) "); break; default: break; diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/UpdateBuilder.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/UpdateBuilder.cs index b482a77fd..86f0c1e76 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/UpdateBuilder.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/UpdateBuilder.cs @@ -32,6 +32,7 @@ namespace SqlSugar public List PrimaryKeys { get; set; } public bool IsOffIdentity { get; set; } public bool IsWhereColumns { get; set; } + public bool? IsListUpdate { get; set; } public virtual string SqlTemplate { @@ -112,6 +113,7 @@ namespace SqlSugar } } + public virtual ExpressionResult GetExpressionValue(Expression expression, ResolveExpressType resolveType, bool isMapping = true) { ILambdaExpressions resolveExpress = this.LambdaExpressions; @@ -156,7 +158,7 @@ namespace SqlSugar } var groupList = DbColumnInfoList.GroupBy(it => it.TableId).ToList(); var isSingle = groupList.Count() == 1; - if (isSingle) + if (isSingle&&this.IsListUpdate==null) { return ToSingleSqlString(groupList); } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SugarProvider/SqlSugarProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SugarProvider/SqlSugarProvider.cs index 1cc1e5016..daaf5b60b 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SugarProvider/SqlSugarProvider.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SugarProvider/SqlSugarProvider.cs @@ -684,7 +684,9 @@ namespace SqlSugar { UpdateObjs = new List(); } - return Updateable(UpdateObjs.ToArray()); + var result= (UpdateableProvider)Updateable(UpdateObjs.ToArray()); + result.UpdateBuilder.IsListUpdate = true; + return result; } public virtual IUpdateable Updateable(T UpdateObj) where T : class, new() { diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Entities/SqlSguarTransaction.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Entities/SqlSguarTransaction.cs new file mode 100644 index 000000000..6177b27d7 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Entities/SqlSguarTransaction.cs @@ -0,0 +1,31 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar +{ + public class SqlSguarTransaction:IDisposable + { + private readonly SqlSugarClient context; + + public SqlSguarTransaction(SqlSugarClient client) + { + context = client; + context.BeginTran(); + } + public void CommitTran() + { + context.CommitTran(); + } + public void RollbackTran() + { + context.RollbackTran(); + } + public void Dispose() + { + context.RollbackTran(); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Common/SugarParameter.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Common/SugarParameter.cs index f654da37e..3a32f4994 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Common/SugarParameter.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Common/SugarParameter.cs @@ -126,8 +126,7 @@ namespace SqlSugar } else if (type == UtilConstants.TimeSpanType) { - if (this.Value != null) - this.Value = this.Value.ToString(); + this.DbType = System.Data.DbType.Time; } else if (type!=null&&type.IsEnum()) { diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/DefaultDbMethod.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/DefaultDbMethod.cs index f0ca5b768..a32862ff8 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/DefaultDbMethod.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/DefaultDbMethod.cs @@ -477,5 +477,18 @@ namespace SqlSugar var array = model.Args.Skip(1).Select(it => it.IsMember?it.MemberName:it.MemberValue).ToArray(); return string.Format("'"+str+ "'", array); } + + public string Abs(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + return string.Format(" ABS({0}) ", parameter.MemberName); + } + + public string Round(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + var parameter2= model.Args[1]; + return string.Format(" ROUND({0},{1}) ", parameter.MemberName, parameter2.MemberName); + } } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/IDbMethods.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/IDbMethods.cs index 71ff30512..7f05f6432 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/IDbMethods.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/IDbMethods.cs @@ -73,5 +73,7 @@ namespace SqlSugar string Oracle_ToChar(MethodCallExpressionModel model); string SqlServer_DateDiff(MethodCallExpressionModel model); string Format(MethodCallExpressionModel model); + string Abs(MethodCallExpressionModel model); + string Round(MethodCallExpressionModel model); } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/SqlFunc.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/SqlFunc.cs index 3c5872439..9f90fd9a4 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/SqlFunc.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/SqlFunc.cs @@ -130,6 +130,11 @@ namespace SqlSugar public static TResult GetSelfAndAutoFill(TResult value) { throw new NotSupportedException("Can only be used in expressions"); } public static DateTime GetDate() { throw new NotSupportedException("Can only be used in expressions"); } public static string GetRandom() { throw new NotSupportedException("Can only be used in expressions"); } + + + public static T Abs( T value) { throw new NotSupportedException("Can only be used in expressions"); } + public static T Round(T value,int precision) { throw new NotSupportedException("Can only be used in expressions"); } + /// /// Subquery /// diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/BaseResolve.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/BaseResolve.cs index 5df61553a..0754ff225 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/BaseResolve.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/BaseResolve.cs @@ -443,6 +443,9 @@ namespace SqlSugar } else if (item.Type.IsClass()) { + var mappingKeys = GetMappingColumns(parameter.CurrentExpression); + var isSameType = mappingKeys.Keys.Count>0; + CallContextThread>.SetData("Exp_Select_Mapping_Key", mappingKeys); this.Expression = item; this.Start(); var shortName = parameter.CommonTempData; @@ -462,7 +465,11 @@ namespace SqlSugar asName = GetAsName(item, shortName, property); } } - else + else if (isSameType) + { + asName = GetAsNameAndShortName(item, shortName, property); + } + else { asName = GetAsName(item, shortName, property); } @@ -503,6 +510,61 @@ namespace SqlSugar } } + private Dictionary GetMappingColumns(Expression currentExpression) + { + Dictionary result = new Dictionary(); + if (currentExpression == null) + { + return result; + } + List types = new List(); + int i = 0; + if (currentExpression is NewExpression) + { + i = (currentExpression as NewExpression).Arguments.Count; + foreach (var item in (currentExpression as NewExpression).Arguments) + { + if (item.Type.IsClass()) + { + types.Add(item.Type); + } + } + } + else if (currentExpression is MemberInitExpression) + { + i = (currentExpression as MemberInitExpression).Bindings.Count; + foreach (var item in (currentExpression as MemberInitExpression).Bindings) + { + MemberAssignment memberAssignment = (MemberAssignment)item; + if (memberAssignment.Expression.Type.IsClass()) + { + types.Add(memberAssignment.Expression.Type); + } + } + } + if (types.Count == i) + { + return result; + } + var array = currentExpression.ToString().Split(','); + foreach (var item in array) + { + var itemArray = item.Split('=').ToArray(); + var last = itemArray.Last().Trim().Split('.').First().TrimEnd(')').TrimEnd('}'); + var first = itemArray.First().Trim(); + if (first.Contains("{")) + { + first = first.Split('{').Last().Trim(); + } + if (first.Contains("(")) + { + first = first.Split('(').Last().Trim(); + } + result.Add(first,last); + } + return result; ; + } + private string GetAsName(Expression item, object shortName, PropertyInfo property) { string asName; @@ -525,7 +587,28 @@ namespace SqlSugar return asName; } + private string GetAsNameAndShortName(Expression item, object shortName, PropertyInfo property) + { + string asName; + var propertyName = property.Name; + var dbColumnName = propertyName; + var mappingInfo = this.Context.MappingColumns.FirstOrDefault(it => it.EntityName == item.Type.Name && it.PropertyName.Equals(propertyName, StringComparison.CurrentCultureIgnoreCase)); + if (mappingInfo.HasValue()) + { + dbColumnName = mappingInfo.DbColumnName; + } + asName = this.Context.GetTranslationText(shortName+"."+item.Type.Name + "." + propertyName); + if (Context.IsJoin) + { + this.Context.Result.Append(Context.GetAsString(asName, dbColumnName, shortName.ObjToString())); + } + else + { + this.Context.Result.Append(Context.GetAsString(asName, dbColumnName)); + } + return asName; + } private static bool IsBoolValue(Expression item) { return item.Type == UtilConstants.BoolType && diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs index a5b5e8b91..82c90cb03 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs @@ -789,6 +789,10 @@ namespace SqlSugar var result = this.Context.DbMehtods.Format(model); this.Context.Parameters.RemoveAll(it => model.Args.Select(x=>x.MemberName.ObjToString()).Contains(it.ParameterName) ); return result; + case "Abs": + return this.Context.DbMehtods.Abs(model); + case "Round": + return this.Context.DbMehtods.Round(model); default: break; } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/ContextMethods.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/ContextMethods.cs index da26e53ba..172e981ed 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/ContextMethods.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/ContextMethods.cs @@ -271,6 +271,7 @@ namespace SqlSugar private Dictionary DataReaderToList(IDataReader reader, Type tType, List classProperties, List reval) { var readerValues = DataReaderToDictionary(reader, tType); + var mappingKeys = CallContextThread>.GetData("Exp_Select_Mapping_Key"); var result = new Dictionary(); foreach (var item in classProperties) { @@ -296,7 +297,7 @@ namespace SqlSugar } else { - result.Add(name, DataReaderToDynamicList_Part(readerValues, item, reval)); + result.Add(name, DataReaderToDynamicList_Part(readerValues, item, reval, mappingKeys)); } } else @@ -370,7 +371,7 @@ namespace SqlSugar Regex.IsMatch(readerValues[item.Name.ToLower()].ToString(), @"^\[{.+\}]$"); } - private Dictionary DataReaderToDynamicList_Part(Dictionary readerValues, PropertyInfo item, List reval) + private Dictionary DataReaderToDynamicList_Part(Dictionary readerValues, PropertyInfo item, List reval, Dictionary mappingKeys=null) { Dictionary result = new Dictionary(); var type = item.PropertyType; @@ -407,6 +408,11 @@ namespace SqlSugar { var key = typeName + "." + name; var info = readerValues.Select(it => it.Key).FirstOrDefault(it => it.ToLower() == key.ToLower()); + if (mappingKeys.ContainsKey(item.Name)) + { + key = mappingKeys[item.Name]+"."+typeName + "." + name; + info = readerValues.Select(it => it.Key).FirstOrDefault(it => it.ToLower() == key.ToLower()); + } if (info != null) { var addItem = readerValues[info]; diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IAdo.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IAdo.cs index 26f4c5d6a..f68496e6a 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IAdo.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IAdo.cs @@ -174,8 +174,8 @@ namespace SqlSugar DbResult UseTran(Action action, Action errorCallBack = null); DbResult UseTran(Func action, Action errorCallBack = null); - Task> UseTranAsync(Action action, Action errorCallBack = null); - Task> UseTranAsync(Func action, Action errorCallBack = null); + Task> UseTranAsync(Func action, Action errorCallBack = null); + Task> UseTranAsync(Func> action, Action errorCallBack = null); IAdo UseStoredProcedure(); diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/ITenant.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/ITenant.cs index d94a8a2f1..c4ade4aaf 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/ITenant.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/ITenant.cs @@ -13,6 +13,7 @@ namespace SqlSugar void RollbackTran(); void ChangeDatabase(dynamic configId); void ChangeDatabase(Func changeExpression); + SqlSguarTransaction UseTran(); DbResult UseTran(Action action, Action errorCallBack = null); Task> UseTranAsync(Func action, Action errorCallBack = null); DbResult UseTran(Func action, Action errorCallBack = null); diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Dm/SqlBuilder/DmQueryBuilder.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Dm/SqlBuilder/DmQueryBuilder.cs index 38868e522..dfc97ac19 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Dm/SqlBuilder/DmQueryBuilder.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Dm/SqlBuilder/DmQueryBuilder.cs @@ -8,7 +8,7 @@ namespace SqlSugar { public override bool IsComplexModel(string sql) { - return Regex.IsMatch(sql, @"AS ""\w+\.\w+"""); + return Regex.IsMatch(sql, @"AS ""\w+\.\w+""")|| Regex.IsMatch(sql, @"AS ""\w+\.\w+\.\w+"""); } public override string SqlTemplate { diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Dm/SqlBuilder/DmUpdateBuilder.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Dm/SqlBuilder/DmUpdateBuilder.cs index 247ac6045..c4cb28bb1 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Dm/SqlBuilder/DmUpdateBuilder.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Dm/SqlBuilder/DmUpdateBuilder.cs @@ -27,7 +27,12 @@ namespace SqlSugar i++; return string.Format("{0} {1} WHERE {2};", updateTable, setValues, string.Join("AND", whereList)); }).ToArray())); - return sb.ToString(); + var result= sb.ToString(); + if (result == "\r\n") + { + return null; + } + return result; } private string GetOracleUpdateColums(int i, DbColumnInfo m) diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/MySql/SqlBuilder/MySqlQueryBuilder.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/MySql/SqlBuilder/MySqlQueryBuilder.cs index 179050eeb..53a7532ca 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/MySql/SqlBuilder/MySqlQueryBuilder.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/MySql/SqlBuilder/MySqlQueryBuilder.cs @@ -31,7 +31,7 @@ namespace SqlSugar #region Common Methods public override bool IsComplexModel(string sql) { - return Regex.IsMatch(sql, @"AS \`\w+\.\w+\`"); + return Regex.IsMatch(sql, @"AS \`\w+\.\w+\`")|| Regex.IsMatch(sql, @"AS \`\w+\.\w+\.\w+\`"); } public override string ToSqlString() { diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/SqlBuilder/OracleQueryBuilder.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/SqlBuilder/OracleQueryBuilder.cs index 89d2e5261..8da10b392 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/SqlBuilder/OracleQueryBuilder.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/SqlBuilder/OracleQueryBuilder.cs @@ -11,7 +11,7 @@ namespace SqlSugar { public override bool IsComplexModel(string sql) { - return Regex.IsMatch(sql, @"AS ""\w+\.\w+"""); + return Regex.IsMatch(sql, @"AS ""\w+\.\w+""")|| Regex.IsMatch(sql, @"AS ""\w+\.\w+\.\w+"""); } public override string SqlTemplate { diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/CodeFirst/PostgreSQLCodeFirst.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/CodeFirst/PostgreSQLCodeFirst.cs index bd89f5f85..caec5a8c3 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/CodeFirst/PostgreSQLCodeFirst.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/CodeFirst/PostgreSQLCodeFirst.cs @@ -37,6 +37,11 @@ namespace SqlSugar ColumnDescription = item.ColumnDescription, Length = item.Length }; + if (propertyType == UtilConstants.DecType) + { + result.Scale = item.DecimalDigits; + result.DecimalDigits = item.DecimalDigits; + } GetDbType(item, propertyType, result); if (result.DataType.Equals("varchar", StringComparison.CurrentCultureIgnoreCase) && result.Length == 0) { diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/DbBind/PostgreSQLDbBind.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/DbBind/PostgreSQLDbBind.cs index 76f67d0ed..e03f4f0ce 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/DbBind/PostgreSQLDbBind.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/DbBind/PostgreSQLDbBind.cs @@ -115,7 +115,7 @@ namespace SqlSugar new KeyValuePair("bit",CSharpDataType.byteArray), new KeyValuePair("bit varying",CSharpDataType.byteArray), new KeyValuePair("varbit",CSharpDataType.@byte), - + new KeyValuePair("time",CSharpDataType.TimeSpan), }; public override List StringThrow { diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/DbMaintenance/PostgreSQLDbMaintenance.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/DbMaintenance/PostgreSQLDbMaintenance.cs index ad9b46b47..e8e94bb9d 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/DbMaintenance/PostgreSQLDbMaintenance.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/DbMaintenance/PostgreSQLDbMaintenance.cs @@ -360,6 +360,10 @@ namespace SqlSugar dataType = "varchar"; } string dataSize = item.Length > 0 ? string.Format("({0})", item.Length) : null; + if (item.DecimalDigits > 0&&item.Length>0 && dataType == "numeric") + { + dataSize = $"({item.Length},{item.DecimalDigits})"; + } string nullType = item.IsNullable ? this.CreateTableNull : CreateTableNotNull; string primaryKey = null; string addItem = string.Format(this.CreateTableColumn, this.SqlBuilder.GetTranslationColumnName(columnName.ToLower()), dataType, dataSize, nullType, primaryKey, ""); diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/Insertable/PostgreSQLInserttable.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/Insertable/PostgreSQLInserttable.cs index 06ddf6d04..acd300eb3 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/Insertable/PostgreSQLInserttable.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/Insertable/PostgreSQLInserttable.cs @@ -13,7 +13,7 @@ namespace SqlSugar { InsertBuilder.IsReturnIdentity = true; PreToSql(); - string sql = InsertBuilder.ToSqlString().Replace("$PrimaryKey", GetIdentityKeys().FirstOrDefault()); + string sql = InsertBuilder.ToSqlString().Replace("$PrimaryKey",this.SqlBuilder.GetTranslationColumnName(GetIdentityKeys().FirstOrDefault())); RestoreMapping(); var result = Ado.GetScalar(sql, InsertBuilder.Parameters == null ? null : InsertBuilder.Parameters.ToArray()).ObjToInt(); return result; @@ -22,7 +22,7 @@ namespace SqlSugar { InsertBuilder.IsReturnIdentity = true; PreToSql(); - string sql = InsertBuilder.ToSqlString().Replace("$PrimaryKey", GetIdentityKeys().FirstOrDefault()); + string sql = InsertBuilder.ToSqlString().Replace("$PrimaryKey", this.SqlBuilder.GetTranslationColumnName(GetIdentityKeys().FirstOrDefault())); RestoreMapping(); var obj = await Ado.GetScalarAsync(sql, InsertBuilder.Parameters == null ? null : InsertBuilder.Parameters.ToArray()); var result = obj.ObjToInt(); @@ -38,7 +38,7 @@ namespace SqlSugar { InsertBuilder.IsReturnIdentity = true; PreToSql(); - string sql = InsertBuilder.ToSqlString().Replace("$PrimaryKey", GetIdentityKeys().FirstOrDefault()); + string sql = InsertBuilder.ToSqlString().Replace("$PrimaryKey", this.SqlBuilder.GetTranslationColumnName(GetIdentityKeys().FirstOrDefault())); RestoreMapping(); var result = Convert.ToInt64(Ado.GetScalar(sql, InsertBuilder.Parameters == null ? null : InsertBuilder.Parameters.ToArray()) ?? "0"); return result; @@ -47,7 +47,7 @@ namespace SqlSugar { InsertBuilder.IsReturnIdentity = true; PreToSql(); - string sql = InsertBuilder.ToSqlString().Replace("$PrimaryKey", GetIdentityKeys().FirstOrDefault()); + string sql = InsertBuilder.ToSqlString().Replace("$PrimaryKey", this.SqlBuilder.GetTranslationColumnName(GetIdentityKeys().FirstOrDefault())); RestoreMapping(); var result = Convert.ToInt64(await Ado.GetScalarAsync(sql, InsertBuilder.Parameters == null ? null : InsertBuilder.Parameters.ToArray()) ?? "0"); return result; diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/SqlBuilder/PostgreSQLQueryBuilder.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/SqlBuilder/PostgreSQLQueryBuilder.cs index 51e1cad28..8c6239f57 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/SqlBuilder/PostgreSQLQueryBuilder.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/SqlBuilder/PostgreSQLQueryBuilder.cs @@ -31,7 +31,7 @@ namespace SqlSugar #region Common Methods public override bool IsComplexModel(string sql) { - return Regex.IsMatch(sql, @"AS ""\w+\.\w+"""); + return Regex.IsMatch(sql, @"AS ""\w+\.\w+""")|| Regex.IsMatch(sql, @"AS ""\w+\.\w+\.\w+"""); } public override string ToSqlString() { diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/SqlServer/SqlBuilder/SqlServerBlukCopy.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/SqlServer/SqlBuilder/SqlServerBlukCopy.cs index 9313b1499..bfdd63280 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/SqlServer/SqlBuilder/SqlServerBlukCopy.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/SqlServer/SqlBuilder/SqlServerBlukCopy.cs @@ -16,7 +16,7 @@ namespace SqlSugar internal InsertBuilder InsertBuilder { get; set; } internal object[] Inserts { get; set; } - public int ExecuteBlukCopy() + public int ExecuteBulkCopy() { if (DbColumnInfoList == null || DbColumnInfoList.Count == 0) return 0; @@ -40,7 +40,7 @@ namespace SqlSugar return DbColumnInfoList.Count; } - public async Task ExecuteBlukCopyAsync() + public async Task ExecuteBulkCopyAsync() { if (DbColumnInfoList == null || DbColumnInfoList.Count == 0) return 0; diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/SqlServer/SqlServerProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/SqlServer/SqlServerProvider.cs index 8b410b9b2..adf8d69b4 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/SqlServer/SqlServerProvider.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/SqlServer/SqlServerProvider.cs @@ -130,6 +130,12 @@ namespace SqlSugar sqlParameter.Size = parameter.Size; sqlParameter.Value = parameter.Value; sqlParameter.DbType = parameter.DbType; + var isTime = parameter.DbType == System.Data.DbType.Time; + if (isTime) + { + sqlParameter.SqlDbType = SqlDbType.Time; + sqlParameter.Value=DateTime.Parse(parameter.Value?.ToString()).TimeOfDay; + } if (sqlParameter.Value!=null&& sqlParameter.Value != DBNull.Value && sqlParameter.DbType == System.Data.DbType.DateTime) { var date = Convert.ToDateTime(sqlParameter.Value); @@ -138,7 +144,7 @@ namespace SqlSugar sqlParameter.Value = Convert.ToDateTime("1753/01/01"); } } - if (parameter.Direction == 0) + if (parameter.Direction == 0) { parameter.Direction = ParameterDirection.Input; } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteQueryBuilder.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteQueryBuilder.cs index 1133f74b3..29a466764 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteQueryBuilder.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteQueryBuilder.cs @@ -31,7 +31,7 @@ namespace SqlSugar #region Common Methods public override bool IsComplexModel(string sql) { - return Regex.IsMatch(sql, @"AS \`\w+\.\w+\`"); + return Regex.IsMatch(sql, @"AS \`\w+\.\w+\`")|| Regex.IsMatch(sql, @"AS \`\w+\.\w+\.\w+\`"); } public override string ToSqlString() { diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarClient.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarClient.cs index 10de59872..7c0a88eb7 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarClient.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarClient.cs @@ -86,6 +86,7 @@ namespace SqlSugar public IInsertable Insertable(T insertObj) where T : class, new() { + Check.Exception(typeof(T).FullName.Contains("System.Collections.Generic.List`"), " need where T: class, new() "); return this.Context.Insertable(insertObj); } @@ -575,6 +576,10 @@ namespace SqlSugar #endregion #region TenantManager + public SqlSguarTransaction UseTran() + { + return new SqlSguarTransaction(this); + } public void AddConnection(ConnectionConfig connection) { Check.ArgumentNullException(connection, "AddConnection.connection can't be null"); @@ -660,7 +665,19 @@ namespace SqlSugar public void CommitTran() { this.Context.Ado.CommitTran(); - AllClientEach(it => it.Ado.CommitTran()); + AllClientEach(it => + { + + try + { + it.Ado.CommitTran(); + } + catch + { + SugarRetry.Execute(() => it.Ado.CommitTran(), new TimeSpan(0, 0, 5), 3); + } + + }); _IsAllTran = false; } public DbResult UseTran(Action action, Action errorCallBack = null) @@ -748,6 +765,7 @@ namespace SqlSugar if (action != null) data = await action(); this.CommitTran(); + result.IsSuccess = true; result.Data = data; } catch (Exception ex) @@ -767,7 +785,19 @@ namespace SqlSugar public void RollbackTran() { this.Context.Ado.RollbackTran(); - AllClientEach(it => it.Ado.RollbackTran()); + AllClientEach(it => + { + + try + { + it.Ado.RollbackTran(); + } + catch + { + SugarRetry.Execute(() => it.Ado.RollbackTran(), new TimeSpan(0, 0, 5), 3); + } + + }); _IsAllTran = false; } public void Close() diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarScope.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarScope.cs index 2bb7434ab..98448daed 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarScope.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarScope.cs @@ -34,62 +34,7 @@ namespace SqlSugar _configs = configs; this._configAction = configAction; } - //public ScopedClient(SqlSugarClient context,Action configAction) - //{ - // this.db = context; - // this.configAction = configAction; - //} - public SqlSugarClient ScopedContext - { - get - { - SqlSugarClient result = null; - var key = _configs.GetHashCode().ToString(); - StackTrace st = new StackTrace(true); - var methods = st.GetFrames(); - var isAsync = UtilMethods.IsAnyAsyncMethod(methods); - if (isAsync) - { - result=GetAsyncContext(key); - } - else - { - result = GetThreadContext(key); - } - return result; - } - } - - private SqlSugarClient GetAsyncContext(string key) - { - SqlSugarClient result = CallContextAsync.GetData(key); - if (result == null) - { - CallContextAsync.SetData(key, new SqlSugarClient(_configs)); - result = CallContextAsync.GetData(key); - if (this._configAction != null) - { - this._configAction(result); - } - } - - return result; - } - - private SqlSugarClient GetThreadContext(string key) - { - SqlSugarClient result = CallContextThread.GetData(key); - if (result == null) - { - CallContextThread.SetData(key, new SqlSugarClient(_configs)); - result = CallContextThread.GetData(key); - if (this._configAction != null) - { - this._configAction(result); - } - } - return result; - } + public SqlSugarClient ScopedContext{ get{ return GetContext();}} public MappingTableList MappingTables { get => ScopedContext.MappingTables; set => ScopedContext.MappingTables = value; } public MappingColumnList MappingColumns { get => ScopedContext.MappingColumns; set => ScopedContext.MappingColumns=value; } @@ -172,7 +117,7 @@ namespace SqlSugar public IDeleteable Deleteable(dynamic primaryKeyValue) where T : class, new() { - return ScopedContext.Deleteable(primaryKeyValue); + return ScopedContext.Deleteable(primaryKeyValue); } public IDeleteable Deleteable(dynamic[] primaryKeyValues) where T : class, new() @@ -651,7 +596,10 @@ namespace SqlSugar { return ScopedContext.Updateable(UpdateObjs); } - + public SqlSguarTransaction UseTran() + { + return ScopedContext.UseTran(); + } public DbResult UseTran(Action action, Action errorCallBack = null) { return ScopedContext.UseTran(action,errorCallBack); @@ -676,5 +624,54 @@ namespace SqlSugar { return ScopedContext.IsAnyConnection(configId); } + + private SqlSugarClient GetContext() + { + SqlSugarClient result = null; + var key = _configs.GetHashCode().ToString(); + StackTrace st = new StackTrace(true); + var methods = st.GetFrames(); + var isAsync = UtilMethods.IsAnyAsyncMethod(methods); + if (isAsync) + { + result = GetAsyncContext(key); + } + else + { + result = GetThreadContext(key); + } + return result; + } + + private SqlSugarClient GetAsyncContext(string key) + { + SqlSugarClient result = CallContextAsync.GetData(key); + if (result == null) + { + CallContextAsync.SetData(key, new SqlSugarClient(_configs)); + result = CallContextAsync.GetData(key); + if (this._configAction != null) + { + this._configAction(result); + } + } + + return result; + } + + private SqlSugarClient GetThreadContext(string key) + { + SqlSugarClient result = CallContextThread.GetData(key); + if (result == null) + { + CallContextThread.SetData(key, new SqlSugarClient(_configs)); + result = CallContextThread.GetData(key); + if (this._configAction != null) + { + this._configAction(result); + } + } + return result; + } } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Utilities/SugarRetry.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Utilities/SugarRetry.cs new file mode 100644 index 000000000..10c7fdd55 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Utilities/SugarRetry.cs @@ -0,0 +1,166 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace SqlSugar +{ + public static class SugarRetry + { + + public static void Execute(Action action, TimeSpan retryInterval, int retryCount = 3) + { + Execute(() => + { + action(); + return null; + }, retryInterval, retryCount); + } + + + public static void Execute(Action action, T1 arg1, TimeSpan retryInterval, int retryCount = 3) + { + Execute((x1) => + { + action(arg1); + return null; + }, arg1, retryInterval, retryCount); + } + + + public static void Execute(Action action, T1 arg1, T2 arg2, TimeSpan retryInterval, int retryCount = 3) + { + Execute((x1, x2) => + { + action(arg1, arg2); + return null; + }, arg1, arg2, retryInterval, retryCount); + } + + + public static void Execute(Action action, T1 arg1, T2 arg2, T3 arg3, TimeSpan retryInterval, int retryCount = 3) + { + Execute((x1, x2, x3) => + { + action(arg1, arg2, arg3); + return null; + }, arg1, arg2, arg3, retryInterval, retryCount); + } + + + public static void Execute(Action action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, TimeSpan retryInterval, int retryCount = 3) + { + Execute((x1, x2, x3, x4) => + { + action(arg1, arg2, arg3, arg4); + return null; + }, arg1, arg2, arg3, arg4, retryInterval, retryCount); + } + + + public static T Execute(Func func, TimeSpan retryInterval, int retryCount = 3) + { + var exceptions = new List(); + + for (int retry = 0; retry < retryCount; retry++) + { + try + { + return func(); + } + catch (Exception ex) + { + exceptions.Add(ex); + Thread.Sleep(retryInterval); + } + } + + throw new AggregateException(exceptions); + } + + + public static T Execute(Func func, T1 arg1, TimeSpan retryInterval, int retryCount = 3) + { + var exceptions = new List(); + + for (int retry = 0; retry < retryCount; retry++) + { + try + { + return func(arg1); + } + catch (Exception ex) + { + exceptions.Add(ex); + Thread.Sleep(retryInterval); + } + } + + throw new AggregateException(exceptions); + } + + public static T Execute(Func func, T1 arg1, T2 arg2, TimeSpan retryInterval, int retryCount = 3) + { + var exceptions = new List(); + + for (int retry = 0; retry < retryCount; retry++) + { + try + { + return func(arg1, arg2); + } + catch (Exception ex) + { + exceptions.Add(ex); + Thread.Sleep(retryInterval); + } + } + + throw new AggregateException(exceptions); + } + + + public static T Execute(Func func, T1 arg1, T2 arg2, T3 arg3, TimeSpan retryInterval, int retryCount = 3) + { + var exceptions = new List(); + + for (int retry = 0; retry < retryCount; retry++) + { + try + { + return func(arg1, arg2, arg3); + } + catch (Exception ex) + { + exceptions.Add(ex); + Thread.Sleep(retryInterval); + } + } + + throw new AggregateException(exceptions); + } + + + public static T Execute(Func func, T1 arg1, T2 arg2, T3 arg3, T4 arg4, TimeSpan retryInterval, int retryCount = 3) + { + var exceptions = new List(); + + for (int retry = 0; retry < retryCount; retry++) + { + try + { + return func(arg1, arg2, arg3, arg4); + } + catch (Exception ex) + { + exceptions.Add(ex); + Thread.Sleep(retryInterval); + } + } + + throw new AggregateException(exceptions); + } + } +}