C#重試公用類

 //Retry機制
    public static class RetryExecutor
    {
        /// <summary>
        /// 重試零個參數無返回值的方法
        /// </summary>
        /// <param name="action">執行方法方法</param>
        /// <param name="retryInterval">重試間隔,單位秒</param>
        /// <param name="retryCount">重試次數</param>
        public static void Execute(Action action, int retryInterval = 3, int retryCount = 3)
        {
            Execute<object>(() =>
            {
                action();
                return null;
            }, retryInterval, retryCount);
        }

        /// <summary>
        /// 重試一個參數無返回值的方法
        /// </summary>
        /// <typeparam name="T1">參數類型1</typeparam>
        /// <param name="action">執行方法方法</param>
        /// <param name="arg1">參數1</param>
        /// <param name="retryInterval">重試間隔,單位秒</param>
        /// <param name="retryCount">重試次數</param>
        public static void Execute<T1>(Action<T1> action, T1 arg1, int retryInterval = 3, int retryCount = 3)
        {
            Execute<T1, object>((x1) =>
            {
                action(arg1);
                return null;
            }, arg1, retryInterval, retryCount);
        }

        /// <summary>
        /// 重試兩個參數無返回值的方法
        /// </summary>
        /// <typeparam name="T1">參數類型1</typeparam>
        /// <typeparam name="T2">參數類型2</typeparam>
        /// <param name="action">執行方法方法</param>
        /// <param name="arg1">參數1</param>
        /// <param name="arg2">參數2</param>
        /// <param name="retryInterval">重試間隔,單位秒</param>
        /// <param name="retryCount">重試次數</param>
        public static void Execute<T1, T2>(Action<T1, T2> action, T1 arg1, T2 arg2, int retryInterval = 3, int retryCount = 3)
        {
            Execute<T1, T2, object>((x1, x2) =>
            {
                action(arg1, arg2);
                return null;
            }, arg1, arg2, retryInterval, retryCount);
        }

        /// <summary>
        /// 重試三個參數無返回值的方法
        /// </summary>
        /// <typeparam name="T1">參數類型1</typeparam>
        /// <typeparam name="T2">參數類型2</typeparam>
        /// <typeparam name="T3">參數類型3</typeparam>
        /// <param name="action">執行方法方法</param>
        /// <param name="arg1">參數1</param>
        /// <param name="arg2">參數2</param>
        /// <param name="arg3">參數3</param>
        /// <param name="retryInterval">重試間隔,單位秒</param>
        /// <param name="retryCount">重試次數</param>
        public static void Execute<T1, T2, T3>(Action<T1, T2, T3> action, T1 arg1, T2 arg2, T3 arg3, int retryInterval = 3, int retryCount = 3)
        {
            Execute<T1, T2, T3, object>((x1, x2, x3) =>
            {
                action(arg1, arg2, arg3);
                return null;
            }, arg1, arg2, arg3, retryInterval, retryCount);
        }

        /// <summary>
        /// 重試四個參數無返回值的方法
        /// </summary>
        /// <typeparam name="T1">參數類型1</typeparam>
        /// <typeparam name="T2">參數類型2</typeparam>
        /// <typeparam name="T3">參數類型3</typeparam>
        /// <typeparam name="T4">參數類型4</typeparam>
        /// <param name="action">執行方法方法</param>
        /// <param name="arg1">參數1</param>
        /// <param name="arg2">參數2</param>
        /// <param name="arg3">參數3</param>
        /// <param name="arg4">參數4</param>
        /// <param name="retryInterval">重試間隔,單位秒</param>
        /// <param name="retryCount">重試次數</param>
        public static void Execute<T1, T2, T3, T4>(Action<T1, T2, T3, T4> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, int retryInterval = 3, 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);
        }

        /// <summary>
        /// 重試零個參數帶返回值
        /// </summary>
        /// <typeparam name="T">返回類型</typeparam>
        /// <param name="func">執行的方法</param>
        /// <param name="retryInterval">重試間隔,單位秒</param>
        /// <param name="retryCount">重試次數</param>
        /// <returns>返回類型T</returns>
        public static T Execute<T>(Func<T> func, int retryInterval = 3, 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);
        }

        /// <summary>
        /// 重試一個參數帶返回值
        /// </summary>
        /// <typeparam name="T1">參數類型1</typeparam>
        /// <typeparam name="T">返回類型</typeparam>
        /// <param name="func">執行的方法</param>
        /// <param name="arg1">參數1</param>
        /// <param name="retryInterval">重試間隔,單位秒</param>
        /// <param name="retryCount">重試次數</param>
        /// <returns>返回類型T</returns>
        public static T Execute<T1, T>(Func<T1, T> func, T1 arg1, int retryInterval = 3, 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);
        }

        /// <summary>
        /// 重試兩個參數帶返回值
        /// </summary>
        /// <typeparam name="T1">參數類型1</typeparam>
        /// <typeparam name="T2">參數類型2</typeparam>
        /// <typeparam name="T">返回類型</typeparam>
        /// <param name="func">執行的方法</param>
        /// <param name="arg1">參數1</param>
        /// <param name="arg2">參數2</param>
        /// <param name="retryInterval">重試間隔,單位秒</param>
        /// <param name="retryCount">重試次數</param>
        /// <returns>返回類型T</returns>
        public static T Execute<T1, T2, T>(Func<T1, T2, T> func, T1 arg1, T2 arg2, int retryInterval = 3, 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);
        }

        /// <summary>
        /// 重試三個參數帶返回值
        /// </summary>
        /// <typeparam name="T1">參數類型1</typeparam>
        /// <typeparam name="T2">參數類型2</typeparam>
        /// <typeparam name="T3">參數類型3</typeparam>
        /// <typeparam name="T">返回類型</typeparam>
        /// <param name="func">執行的方法</param>
        /// <param name="arg1">參數1</param>
        /// <param name="arg2">參數2</param>
        /// <param name="arg3">參數3</param>
        /// <param name="retryInterval">重試間隔,單位秒</param>
        /// <param name="retryCount">重試次數</param>
        /// <returns>返回類型T</returns>
        public static T Execute<T1, T2, T3, T>(Func<T1, T2, T3, T> func, T1 arg1, T2 arg2, T3 arg3, int retryInterval = 3, 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);
        }

        /// <summary>
        /// 重試四個參數帶返回值
        /// </summary>
        /// <typeparam name="T1">參數類型1</typeparam>
        /// <typeparam name="T2">參數類型2</typeparam>
        /// <typeparam name="T3">參數類型3</typeparam>
        /// <typeparam name="T4">參數類型4</typeparam>
        /// <typeparam name="T">返回類型</typeparam>
        /// <param name="func">執行的方法</param>
        /// <param name="arg1">參數1</param>
        /// <param name="arg2">參數2</param>
        /// <param name="arg3">參數3</param>
        /// <param name="arg4">參數4</param>
        /// <param name="retryInterval">重試間隔,單位秒</param>
        /// <param name="retryCount">重試次數</param>
        /// <returns>返回類型T</returns>
        public static T Execute<T1, T2, T3, T4, T>(Func<T1, T2, T3, T4, T> func, T1 arg1, T2 arg2, T3 arg3, T4 arg4, int retryInterval = 3, 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);
        }
    }