lsm/SqlSugar
1
0
Fork 0
mirror of https://gitee.com/dotnetchina/SqlSugar.git synced 2025-07-31 15:56:25 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

code optimization

Browse Source
This commit is contained in:
sunkaixuna 2021-08-24 20:49:44 +08:00
parent abafd656ab
commit 8d1afad856
3 changed files with 179 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -209,6 +209,7 @@
<Compile Include="SqlSugarClient.cs" />
<Compile Include="Utilities\CallContext.cs" />
<Compile Include="Utilities\CallContextAsync.cs" />
<Compile Include="Utilities\SugarRetry.cs" />
<Compile Include="Utilities\DataTableExtensions.cs" />
<Compile Include="Utilities\ReflectionExtensions.cs" />
<Compile Include="Realization\MySql\CodeFirst\MySqlCodeFirst.cs" />

14
Src/Asp.Net/SqlSugar/SqlSugarClient.cs
View File

@ -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<bool> UseTran(Action action, Action<Exception> 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()

166
Src/Asp.Net/SqlSugar/Utilities/SugarRetry.cs Normal file
View File

@ -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<object>(() =>
{
action();
return null;
}, retryInterval, retryCount);
}
public static void Execute<T1>(Action<T1> action, T1 arg1, TimeSpan retryInterval, int retryCount = 3)
{
Execute<T1, object>((x1) =>
{
action(arg1);
return null;
}, arg1, retryInterval, retryCount);
}
public static void Execute<T1, T2>(Action<T1, T2> action, T1 arg1, T2 arg2, TimeSpan retryInterval, int retryCount = 3)
{
Execute<T1, T2, object>((x1, x2) =>
{
action(arg1, arg2);
return null;
}, arg1, arg2, retryInterval, retryCount);
}
public static void Execute<T1, T2, T3>(Action<T1, T2, T3> action, T1 arg1, T2 arg2, T3 arg3, TimeSpan retryInterval, int retryCount = 3)
{
Execute<T1, T2, T3, object>((x1, x2, x3) =>
{
action(arg1, arg2, arg3);
return null;
}, arg1, arg2, arg3, retryInterval, retryCount);
}
public static void Execute<T1, T2, T3, T4>(Action<T1, T2, T3, T4> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, TimeSpan retryInterval, int retryCount = 3)
{
Execute<T1, T2, T3, T4, object>((x1, x2, x3, x4) =>
{
action(arg1, arg2, arg3, arg4);
return null;
}, arg1, arg2, arg3, arg4, retryInterval, retryCount);
}
public static T Execute<T>(Func<T> func, TimeSpan retryInterval, int retryCount = 3)
{
var exceptions = new List<Exception>();
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<T1, T>(Func<T1, T> func, T1 arg1, TimeSpan retryInterval, int retryCount = 3)
{
var exceptions = new List<Exception>();
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<T1, T2, T>(Func<T1, T2, T> func, T1 arg1, T2 arg2, TimeSpan retryInterval, int retryCount = 3)
{
var exceptions = new List<Exception>();
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<T1, T2, T3, T>(Func<T1, T2, T3, T> func, T1 arg1, T2 arg2, T3 arg3, TimeSpan retryInterval, int retryCount = 3)
{
var exceptions = new List<Exception>();
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<T1, T2, T3, T4, T>(Func<T1, T2, T3, T4, T> func, T1 arg1, T2 arg2, T3 arg3, T4 arg4, TimeSpan retryInterval, int retryCount = 3)
{
var exceptions = new List<Exception>();
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);
}
}
}