C#异常执行重试的实现方法

一 模式介绍

重试模式，是应用在异常处理中，发生异常的时候，能够对业务程序进行重新调用，在实际中，可以使用polly提供稳定，简单的用法，自己实现主要是对模式的一种了解。

二 模式实现

public class retrypattern
    {
        /**
         * 重试模式可以用polly替代
         * 自己实现一种模式
         */

        #region 构造函数

        public retrypattern()
        {
        }

        #endregion 构造函数

        #region 变量

        private uint maxtrycount; // 最大重试次数
        private uint currenttrycount; // 当前重试的次数
        private bool runresult = true; // 执行结果

        #endregion 变量

        #region 方法

        #region 设置最大重试次数

        public void setmaxcount(uint trycount)
        {
            // 校验
            if (trycount == 0) throw new argumentexception("重试次数不能为0");

            maxtrycount = trycount;
        }

        #endregion 设置最大重试次数

        #region 是否需要重试

        public bool isretry()
        {
            if (runresult || currenttrycount == maxtrycount)
                return false;
            else
            {
                runresult = true;
                return true;
            }
        }

        #endregion 是否需要重试

        #region 获取当前重试次数

        public uint getcurrenttrycount()
        {
            return currenttrycount + 1;
        }

        #endregion 获取当前重试次数

        #region 重试

        public void retryhandle()
        {
            runresult = false;
            currenttrycount++;
        }

        #endregion 重试

        #endregion 方法
    }

ps：下面通过代码看下c# 异常重试策略

using system;
using system.collections.generic;
using system.componentmodel;
using system.data;
using system.drawing;
using system.linq;
using system.text;
using system.threading.tasks;
using system.windows.forms;
using polly;
using polly.bulkhead;
using polly.circuitbreaker;
using polly.fallback;
using polly.noop;
using polly.registry;
using polly.retry;
using polly.timeout;
using polly.utilities;
using polly.wrap;
using system.net.http;

namespace circuitbreak_test
{
    public partial class form1 : form
    {
        public form1()
        {
            initializecomponent();
        }

        private void button1_click(object sender, eventargs e)
        {

            try
            {
                var retrytwotimespolicy =
                     policy
                         .handle<dividebyzeroexception>()
                         .retry(3, (ex, count) =>
                         {
                             console.writeline("执行失败! 重试次数 {0}", count);
                             console.writeline("异常来自 {0}", ex.gettype().name);
                         });
                retrytwotimespolicy.execute(() =>
                {
                    compute();
                });
            }
            catch (dividebyzeroexception e1)
            {
                console.writeline($"excuted failed,message: ({e1.message})");

            }

            policy policy = policy.handle<timeoutexception>()
               .waitandretryasync(5, retryattempt => timespan.fromseconds(5), (exception, retrycount) =>
               {
                   //logger.error(exception);
                   string xx = "";
               });

            var result = policy.executeasync(() => test());


            policy _circuitbreakerpolicy = policy
                .handle<httprequestexception>()
                .or<timeoutrejectedexception>()
                .or<timeoutexception>()
                .circuitbreakerasync(
                    exceptionsallowedbeforebreaking: 5,
                    durationofbreak: new timespan(),
                    onbreak: (ex, breakdelay) =>
                    {
                        
                    },
                    onreset: () => { },
                    onhalfopen: () => { }
                    );

            var fallbackpolicy =
               policy<string>
                   .handle<exception>()
                   .fallback("执行失败，返回fallback");

            var fallback = fallbackpolicy.execute(() =>
            {
                throw new exception();
            });
            console.writeline(fallback);

           
        }

        static int compute()
        {
            var a = 0;
            return 1 / a;
        }

        private static async task test()
        {
            using (httpclient httpclient = new httpclient())
            {
                var response = httpclient.getasync("http://news1.cnblogs.com/category/getcategorylist?bigcateid=11&loadtype=0").result;
                await response.content.readasstringasync();
            }
        }
    }
}

到此这篇关于c#异常执行重试的一种实现方法的文章就介绍到这了,更多相关c#异常重试内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！