diff --git a/Src/Asp.Net/SqlSugar/SqlSugar.csproj b/Src/Asp.Net/SqlSugar/SqlSugar.csproj index bf786cdd3..1ce021eaa 100644 --- a/Src/Asp.Net/SqlSugar/SqlSugar.csproj +++ b/Src/Asp.Net/SqlSugar/SqlSugar.csproj @@ -209,6 +209,7 @@ + diff --git a/Src/Asp.Net/SqlSugar/SqlSugarClient.cs b/Src/Asp.Net/SqlSugar/SqlSugarClient.cs index 585fd69df..d770f27d3 100644 --- a/Src/Asp.Net/SqlSugar/SqlSugarClient.cs +++ b/Src/Asp.Net/SqlSugar/SqlSugarClient.cs @@ -659,7 +659,12 @@ namespace SqlSugar public void CommitTran() { this.Context.Ado.CommitTran(); - AllClientEach(it => it.Ado.CommitTran()); + AllClientEach(it => + { + + it.Ado.CommitTran(); + + }); _IsAllTran = false; } public DbResult UseTran(Action action, Action errorCallBack = null) @@ -766,7 +771,12 @@ namespace SqlSugar public void RollbackTran() { this.Context.Ado.RollbackTran(); - AllClientEach(it => it.Ado.RollbackTran()); + AllClientEach(it => + { + + it.Ado.RollbackTran(); + + }); _IsAllTran = false; } public void Close() diff --git a/Src/Asp.Net/SqlSugar/Utilities/SugarRetry.cs b/Src/Asp.Net/SqlSugar/Utilities/SugarRetry.cs new file mode 100644 index 000000000..10c7fdd55 --- /dev/null +++ b/Src/Asp.Net/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); + } + } +}