C#重试机制类

最新推荐文章于 2024-05-30 08:02:58 发布
最新推荐文章于 2024-05-30 08:02:58 发布
阅读量2.1k 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangwenting6/article/details/78048902
版权 
public static class Retry
    {
        /// <summary>
        /// 重试零个参数无返回值的方法
        /// </summary>
        /// <param name="action">执行方法方法</param>
        /// <param name="retryInterval">重试间隔</param>
        /// <param name="retryCount">重试次数</param>
        public static void Execute(Action action, TimeSpan retryInterval, 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, TimeSpan retryInterval, 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, TimeSpan retryInterval, 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, TimeSpan retryInterval, 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, 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);
        }

        /// <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, 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);
        }

        /// <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, 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);
        }

        /// <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, 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);
        }

        /// <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, 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);
        }

        /// <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, 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);
        }
    }
复制代码
水滴洞穿
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
dotnet-retry:.NET重试机制
05-19
点网重试.NET的简单，轻量级重试机制。目录描述重试政策顺序的指数的班级例子测验执照描述用C＃编写的重试库，它尝试使用给定的重试策略执行给定的操作。 操作可以是无效的，也可以返回值。 如果某个操作由于任何...
c#异常重试机制
weixin_33690367的博客
01-15 1837
     有时候我们碰到程序异常了，想让程序继续重新执行，进行重试，这时候就需要有一个合适的方法来进行操作； 自己写代码控制太麻烦了，也容易出错。这时候当然是站在巨人的肩膀上， https://github.com/App-vNext/Polly  Polly 一个非常好用的类库 写了个测试 既可以指定异常之后重试的次数，也可以之后重试的间隔时间 1 using Polly; 2...
C# Retry重试操作解决方案（附源码）
weixin_34115824的博客
06-20 296
一、前言 (1)对于Thread的Abort方法，如果线程当前正在执行的是一段非托管代码，那么CLR就不会抛出ThreadAbortException，只有当代码继续回到CLR中时，才会引发ThreadAbortException。当然，即便是在CLR环境中ThreadAbortException也不会立即引发。(2)对于BackgroundWorker的CancelAsync方法，需要设置Wo...
如何在 C# 中使用 Polly：轻松处理故障和重试
最新发布
dotNET跨平台
05-30 78
概述：在本文中，我们将探讨如何在 C# 中使用 Polly，以及它如何帮助轻松处理错误和重试。Polly 是一个常用的 NuGet 包，它提供了一组强大的工具和模式，可以大大简化代码中的故障处理和重试机制。通过在代码中利用 Polly，我们可以处理各种类型的故障，例如网络错误或数据库连接失败。然后，我们可以实施智能重试策略，以确保当其中一个不可避免地出现问题时，我们的应用程序不会崩溃（记住：墨菲定...
C#异常Retry通用类
weixin_34381666的博客
02-26 284
系统里面常常调用服务和读写文件里面需要对发生异常，操作失败时进行Retry来尽可能程序的健壮性。最近工作中遇到了，参考了网上的资料，扩展了下。在博客里面备用下： //Retry机制 public static class Retry { /// &lt;summary&gt; /// 重试零个参数无返回值的方法 ///...
C#异常重试通用类Retry
weixin_33924770的博客
09-28 595
//Retry机制 public static class Retry { /// <summary> /// 重试零个参数无返回值的方法 /// </summary> /// <param name="action">执行方法方法</param> ...
C#匿名方法–异常Retry机制和WinForm线程安全访问
TonyWang的专栏
11-12 2339
来源:DanceFire的专栏 - CSDNBlog　　用C# 2.0的朋友可能会经常使用匿名方法(Anonymous Methods)和匿名委托(Anonymous Delegate)。在这里我说2个比较常用的应用环境。　　1、Retry机制　　C#和C++, Java一样拥有异常处理机制，我相信很多朋友和我一样，第一次接触异常的时候，都非常希望异常能够像内核捕获内存page fault异常一样
【转载】C#异常Retry通用类
dianyin7770的博客
12-26 114
//Retry机制 public static class Retry { /// <summary> /// 重试零个参数无返回值的方法 /// </summary> /// <param name="action">执行方法方法</param&gt...
C# 中分享重试控制
君子居易
08-09 247
【代码】 C# 中分享重试控制。
C# ES通用类demo
03-01
10. **错误处理和重试机制**：在与Elasticsearch交互时，可能遇到网络问题或服务器异常。`ESCommon`类可能包含了错误处理逻辑，如重试策略，以确保操作的可靠性。 11. **最佳实践**：在实际应用中，还需要考虑索引...
Toucan:C＃的轻量级异步重试解决方案
03-30
Toucan 是一个针对 C# 开发者的轻量级库，旨在提供简洁而强大的异步重试机制。在软件开发中，尤其是在网络通信或者访问外部服务时，偶尔会遇到暂时性的错误，如网络超时、服务不可用等。在这种情况下，一种常见的...
C#网速测试源码
04-20
可以通过设置超时机制，以及处理IOException等异常，确保程序在遇到网络问题时能优雅地退出或重试。 5. **用户界面**：在实际的应用中，我们通常会为用户提供一个友好的界面，显示测试进度和结果。C#的Windows ...
c# restsharp 帮助类,c# restsharp 帮助类
03-31
实际应用中，可能需要更详细的错误信息，如重试逻辑、日志记录等。 7. **扩展功能**：除了基本的GET、POST方法，还可以添加其他功能，如上传文件、处理OAuth认证、设置自定义请求头等。 通过这样的帮助类，C#...
C# 实现retry
weixin_33754065的博客
04-18 526
C# 实现retry C# 有try-catch ,但是没有retry 功能，通过用有限次循环的办法来模拟Retry，当然中间需要加一个等待的过程。 我们可以利用C#的匿名方法(anonymous methods)和匿名委托(anonymous delegate)修饰此功能 using System; using System.C...
C#执行任务Task，如果任务超时的话就取消当前任务，重新执行,规定次数内执行成功则执行成功的委托，超过规定的次数则失败的委托
fyyan的博客
04-15 2020
如果最先完成的任务是指定的任务 task，则 Task.WhenAny 的返回结果即为 task，这意味着 await Task.WhenAny(task, Task.Delay(timeout)) 将返回 task 对象的结果，此时，if 语句的条件判断结果为 True，进入 if 块内部的代码。否则，如果超时任务先完成，Task.WhenAny 的返回结果将是超时任务 Task.Delay，在这种情况下，if 语句将不会执行，代码将继续执行 Task.Delay 后面的语句。
关于接口的超时重试
Oliver_Liuqifan的博客
09-26 127
接口超时重试的代码实践
C#中如何处理幂等性中的冲突问题
java专栏
04-06 155
在设计系统时，考虑使用幂等性设计模式，如“先检查后执行”（Check-and-Act）或“先执行后检查”（Act-and-Verify）。在C#中处理幂等性中的冲突问题，通常涉及到确保即使在多次尝试执行相同操作时，也不会导致数据不一致或其他不良后果。在执行操作之前，检查资源的当前状态。如果操作失败并导致数据不一致，可以使用补偿事务来撤销已执行的操作，恢复到一致的状态。这通常涉及到记录操作的日志，并在必要时执行相应的回滚操作。在重试之前，可以检查操作是否已经执行过，以避免重复执行。
C# 自定义重发机制
丘鸣山的博客
07-27 632
重发机制
C# 如何实现支付回调的重试通知机制
06-03
在 C# 中实现支付回调的重试通知机制的一般流程如下： 1. 接收到支付回调请求。 2. 处理支付回调请求，如果处理失败，则记录请求信息到数据库中，并设置重试次数为 0。 3. 启动计时器，根据重试次数和时间间隔进行通知。 4. 计时器触发后，从数据库中读取未成功处理的请求信息，进行重试通知。 5. 如果重试成功，则从数据库中删除请求信息；如果重试失败，则将重试次数加 1，并更新数据库中的请求信息。 6. 重复步骤 4 和 5，直到达到最大重试次数。 下面是一个简单的 C# 代码示例，实现了支付回调的重试通知机制： ```csharp using System; using System.Collections.Generic; using System.Data.SqlClient; using System.ServiceProcess; using System.Threading; namespace PaymentNotificationService { public partial class PaymentNotificationService : ServiceBase { private Timer retryTimer; private const int MAX_RETRY_COUNT = 8; private const int TIME_INTERVAL_1 = 4 * 60 * 1000; // 4 minutes private const int TIME_INTERVAL_2 = 10 * 60 * 1000; // 10 minutes private const int TIME_INTERVAL_3 = 1 * 60 * 60 * 1000; // 1 hour private const int TIME_INTERVAL_4 = 2 * 60 * 60 * 1000; // 2 hours private const int TIME_INTERVAL_5 = 6 * 60 * 60 * 1000; // 6 hours private const int TIME_INTERVAL_6 = 15 * 60 * 60 * 1000; // 15 hours public PaymentNotificationService() { InitializeComponent(); } protected override void OnStart(string[] args) { // 启动计时器 retryTimer = new Timer(new TimerCallback(RetryNotification), null, 0, Timeout.Infinite); } protected override void OnStop() { // 停止计时器 retryTimer.Change(Timeout.Infinite, Timeout.Infinite); } private void RetryNotification(object state) { // 从数据库中读取未成功处理的请求信息 List<PaymentNotification> notifications = GetUnprocessedNotifications(); foreach (PaymentNotification notification in notifications) { if (notification.RetryCount < MAX_RETRY_COUNT) { // 根据重试次数设置时间间隔 int timeInterval = 0; switch (notification.RetryCount) { case 0: timeInterval = 0; break; case 1: timeInterval = TIME_INTERVAL_1; break; case 2: timeInterval = TIME_INTERVAL_2; break; case 3: timeInterval = TIME_INTERVAL_3; break; case 4: timeInterval = TIME_INTERVAL_4; break; case 5: timeInterval = TIME_INTERVAL_5; break; case 6: timeInterval = TIME_INTERVAL_6; break; default: break; } // 进行重试通知 bool success = Notify(notification); if (success) { // 重试成功，从数据库中删除请求信息 DeleteNotification(notification); } else { // 重试失败，更新数据库中的请求信息 UpdateNotification(notification); } // 进入下一次计时 retryTimer.Change(timeInterval, Timeout.Infinite); } else { // 达到最大重试次数，从数据库中删除请求信息 DeleteNotification(notification); } } } private List<PaymentNotification> GetUnprocessedNotifications() { // 从数据库中读取未成功处理的请求信息 List<PaymentNotification> notifications = new List<PaymentNotification>(); using (SqlConnection connection = new SqlConnection("your_connection_string")) { connection.Open(); SqlCommand command = new SqlCommand("SELECT * FROM PaymentNotifications WHERE RetryCount < @maxRetryCount", connection); command.Parameters.AddWithValue("@maxRetryCount", MAX_RETRY_COUNT); SqlDataReader reader = command.ExecuteReader(); while (reader.Read()) { PaymentNotification notification = new PaymentNotification(); notification.Id = reader.GetInt32(0); notification.OrderId = reader.GetString(1); notification.Amount = reader.GetDecimal(2); notification.RetryCount = reader.GetInt32(3); notification.CreateTime = reader.GetDateTime(4); notifications.Add(notification); } reader.Close(); } return notifications; } private bool Notify(PaymentNotification notification) { // 实现通知的具体逻辑 // ... return true; } private void UpdateNotification(PaymentNotification notification) { // 更新数据库中的请求信息 using (SqlConnection connection = new SqlConnection("your_connection_string")) { connection.Open(); SqlCommand command = new SqlCommand("UPDATE PaymentNotifications SET RetryCount = @retryCount WHERE Id = @id", connection); command.Parameters.AddWithValue("@retryCount", notification.RetryCount + 1); command.Parameters.AddWithValue("@id", notification.Id); command.ExecuteNonQuery(); } } private void DeleteNotification(PaymentNotification notification) { // 从数据库中删除请求信息 using (SqlConnection connection = new SqlConnection("your_connection_string")) { connection.Open(); SqlCommand command = new SqlCommand("DELETE FROM PaymentNotifications WHERE Id = @id", connection); command.Parameters.AddWithValue("@id", notification.Id); command.ExecuteNonQuery(); } } } public class PaymentNotification { public int Id { get; set; } public string OrderId { get; set; } public decimal Amount { get; set; } public int RetryCount { get; set; } public DateTime CreateTime { get; set; } } } ``` 在上面的代码中，我们使用了一个 `Timer` 计时器来实现支付回调的重试通知机制。在 `OnStart` 方法中启动计时器，在 `OnStop` 方法中停止计时器。计时器在 `RetryNotification` 方法中触发，从数据库中读取未成功处理的请求信息，进行重试通知。在 `Notify` 方法中实现了具体的通知逻辑，您可以根据自己的需求进行修改。在 `UpdateNotification` 和 `DeleteNotification` 方法中分别实现了更新和删除请求信息的逻辑。同时，代码中的时间间隔参数也可以根据您的需求进行修改。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值