C#重试公用类

 //Retry机制
    public static class RetryExecutor
    {
        /// 

        /// 重试零个参数无返回值的方法
        /// 
        /// 执行方法方法
        /// 重试间隔,单位秒
        /// 重试次数
        public static void Execute(Action action, int retryInterval = 3, int retryCount = 3)
        {
            Executeobject>(() =>
            {
                action();
                return null;
            }, retryInterval, retryCount);
        }

        /// 

        /// 重试一个参数无返回值的方法
        /// 
        /// 参数类型1
        /// 执行方法方法
        /// 参数1
        /// 重试间隔,单位秒
        /// 重试次数
        public static void Execute(Action action, T1 arg1, int retryInterval = 3, int retryCount = 3)
        {
            Executeobject>((x1) =>
            {
                action(arg1);
                return null;
            }, arg1, retryInterval, retryCount);
        }

        /// 

        /// 重试两个参数无返回值的方法
        /// 
        /// 参数类型1
        /// 参数类型2
        /// 执行方法方法
        /// 参数1
        /// 参数2
        /// 重试间隔,单位秒
        /// 重试次数
        public static void Execute(Action action, T1 arg1, T2 arg2, int retryInterval = 3, int retryCount = 3)
        {
            Executeobject>((x1, x2) =>
            {
                action(arg1, arg2);
                return null;
            }, arg1, arg2, retryInterval, retryCount);
        }

        /// 

        /// 重试三个参数无返回值的方法
        /// 
        /// 参数类型1
        /// 参数类型2
        /// 参数类型3
        /// 执行方法方法
        /// 参数1
        /// 参数2
        /// 参数3
        /// 重试间隔,单位秒
        /// 重试次数
        public static void Execute(Action action, T1 arg1, T2 arg2, T3 arg3, int retryInterval = 3, int retryCount = 3)
        {
            Executeobject>((x1, x2, x3) =>
            {
                action(arg1, arg2, arg3);
                return null;
            }, arg1, arg2, arg3, retryInterval, retryCount);
        }

        /// 

        /// 重试四个参数无返回值的方法
        /// 
        /// 参数类型1
        /// 参数类型2
        /// 参数类型3
        /// 参数类型4
        /// 执行方法方法
        /// 参数1
        /// 参数2
        /// 参数3
        /// 参数4
        /// 重试间隔,单位秒
        /// 重试次数
        public static void Execute(Action action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, int retryInterval = 3, int retryCount = 3)
        {
            Executeobject>((x1, x2, x3, x4) =>
            {
                action(arg1, arg2, arg3, arg4);
                return null;
            }, arg1, arg2, arg3, arg4, retryInterval, retryCount);
        }

        /// 

        /// 重试零个参数带返回值
        /// 
        /// 返回类型
        /// 执行的方法
        /// 重试间隔,单位秒
        /// 重试次数
        /// 返回类型T
        public static T Execute(Func func, int retryInterval = 3, int retryCount = 3)
        {
            var exceptions = new List();

            for (int retry = 0; retry )
            {
                try
                {
                    return func();
                }
                catch (Exception ex)
                {
                    exceptions.Add(ex);
                    Thread.Sleep(retryInterval);
                }
            }

            throw new AggregateException(exceptions);
        }

        /// 

        /// 重试一个参数带返回值
        /// 
        /// 参数类型1
        /// 返回类型
        /// 执行的方法
        /// 参数1
        /// 重试间隔,单位秒
        /// 重试次数
        /// 返回类型T
        public static T Execute(Func func, T1 arg1, int retryInterval = 3, int retryCount = 3)
        {
            var exceptions = new List();

            for (int retry = 0; retry )
            {
                try
                {
                    return func(arg1);
                }
                catch (Exception ex)
                {
                    exceptions.Add(ex);
                    Thread.Sleep(retryInterval);
                }
            }

            throw new AggregateException(exceptions);
        }

        /// 

        /// 重试两个参数带返回值
        /// 
        /// 参数类型1
        /// 参数类型2
        /// 返回类型
        /// 执行的方法
        /// 参数1
        /// 参数2
        /// 重试间隔,单位秒
        /// 重试次数
        /// 返回类型T
        public static T Execute(Func func, T1 arg1, T2 arg2, int retryInterval = 3, int retryCount = 3)
        {
            var exceptions = new List();

            for (int retry = 0; retry )
            {
                try
                {
                    return func(arg1, arg2);
                }
                catch (Exception ex)
                {
                    exceptions.Add(ex);
                    Thread.Sleep(retryInterval);
                }
            }

            throw new AggregateException(exceptions);
        }

        /// 

        /// 重试三个参数带返回值
        /// 
        /// 参数类型1
        /// 参数类型2
        /// 参数类型3
        /// 返回类型
        /// 执行的方法
        /// 参数1
        /// 参数2
        /// 参数3
        /// 重试间隔,单位秒
        /// 重试次数
        /// 返回类型T
        public static T Execute(Func func, T1 arg1, T2 arg2, T3 arg3, int retryInterval = 3, int retryCount = 3)
        {
            var exceptions = new List();

            for (int retry = 0; retry )
            {
                try
                {
                    return func(arg1, arg2, arg3);
                }
                catch (Exception ex)
                {
                    exceptions.Add(ex);
                    Thread.Sleep(retryInterval);
                }
            }

            throw new AggregateException(exceptions);
        }

        /// 

        /// 重试四个参数带返回值
        /// 
        /// 参数类型1
        /// 参数类型2
        /// 参数类型3
        /// 参数类型4
        /// 返回类型
        /// 执行的方法
        /// 参数1
        /// 参数2
        /// 参数3
        /// 参数4
        /// 重试间隔,单位秒
        /// 重试次数
        /// 返回类型T
        public static T Execute(Func func, T1 arg1, T2 arg2, T3 arg3, T4 arg4, int retryInterval = 3, int retryCount = 3)
        {
            var exceptions = new List();

            for (int retry = 0; retry )
            {
                try
                {
                    return func(arg1, arg2, arg3, arg4);
                }
                catch (Exception ex)
                {
                    exceptions.Add(ex);
                    Thread.Sleep(retryInterval);
                }
            }

            throw new AggregateException(exceptions);
        }
    }