支配端必要发表心跳数据来判定受控端的在线状态,本文首要来上学以下几点建议

建议63:避免“吃掉”异常

前言  

嵌套万分是很凶险的作为,一相当的大心就就会将10分堆栈新闻,相当于的确的Bug出处隐藏起来。那还不是最惨重的,最要紧的便是“吃掉”非凡,即捕获,然后不向上层throw。

  本文已联合到http://www.cnblogs.com/aehyok/p/3624579.html。本文主要来学习以下几点建议

幸免“吃掉”很是,并不是说不应有“吃掉”格外,而是那里有个主要条件:该特别可被预感,并且普通情形它无法算是2个Bug。

  建议6壹 、幸免在finally内撰写无效代码

 

  提出6贰 、制止嵌套十分

想象你正在对上万份文件举办解密,这几个文件来自分歧的客户端,很有肯能存在文件被磨损的状态,你的对象是将解密出来的数量插入数据库。那些时候,你不得不忽略掉这一个解密退步的文本,让一切经过进展下去。当然,记录日志时必需的,因为中期你或然对解密失利的文书做联合处理。

  建议63、避免“吃掉”异常

 

  提议6四 、为循环扩大Tester-Doer形式而不是将try-catch置于循环内

此外一种意况,或许连记录日志都不需求。在对上千个受控端实行支配的分布式系统中,控制端需求揭橥心跳数据来判定受控端的在线状态。日常的做法是保养一个型号量,要是在2个可承受的遏止时间内(如500ms)心跳数据发送退步,那么控制端线程将不会接到信号,即能够看清受控端的短线状态。那种境况下对每一回SocketException进行记录,平时是未曾意思的。

提出6① 、防止在finally内撰写无效代码

 

先直接来看一下三个不难的try catch方法

比方您不了解怎么处理1个可怜,那么相对不要“吃掉”非凡,倘诺您一非常大心“吃掉”了3个应该往上传递的十二分,那么就可能诞生二个Bug,而且,消除它会很费周折。

    public class User
    {
        public string Name { get; set; }
    }

    class Program
    {

        static void Main(string[] args)
        {
            Console.WriteLine(Test1());
            Console.WriteLine(Test2());
            Console.WriteLine(Test3().Name);

            Console.ReadLine();
        }

        public static int Test1()
        {
            int i = 0;
            try
            {
                i = 1;
            }
            finally
            {
                i = 2;
                Console.WriteLine("\t 将int结果改为2,finnally执行完毕。");
            }
            return i;
        }

        public static int Test2()
        {
            int i = 0;
            try
            {
                return i = 1;
            }
            finally
            {
                i = 2;
                Console.WriteLine("\t 将int结果改为2,finnally执行完毕。");
            }
        }

 

看完代码你内心大概也有了2个答案了吧

 

图片 1

转自:《编写高品质代码革新C#程序的157个建议》陆敏技

那一个如若经过IL来解释,照旧比较简单的,在此就不开始展览赘述了。

  在CLHighlander中,方法的参数以及重临值都是用栈来保存的。在章程内部,会首先将参数依次压栈,当必要利用这几个参数的时候,方法会直接去栈里取用参数值,方法重返时,会将再次来到值压入栈顶。尽管参数的类型是值类型,压栈的正是复制的值,若是是引用类型,则在章程内对此参数的改动也会带到艺术外。

建议6② 、幸免嵌套相当  

在建议59中一度强调过,应该允许极度在调用堆栈中往上传出,不要过多应用catch,然后再throw。果断利用catch会带来七个难题:

壹 、代码越多了。那看起来就像你根本不亮堂该怎么处理卓殊,所以你总在不停地catch.

② 、隐藏了库房新闻,使你不领悟真正发出特其他地方。

来看一下底下的代码

        static void Main(string[] args)
        {
            try
            {
                Console.WriteLine("NoTry\n");
                MethodNoTry();
            }
            catch (Exception exception)
            {
                Console.WriteLine(exception.StackTrace);
            }
            try
            {
                Console.WriteLine("WithTry\n");
                MethodWithTry();
            }
            catch (Exception exception)
            {
                Console.WriteLine(exception.StackTrace);
            }
            Console.ReadLine();
        }

        public static int Method()
        {
            int i = 0;
            return 10 / i;
        }

        public static void MethodNoTry()
        {
            Method();
        }

        public static void MethodWithTry()
        {
            try
            {
                Method();
            }
            catch (Exception exception)
            {
                throw exception;
            }
        }

实践结果

图片 2

  能够窥见,MethodNoTry的方式能够查阅到产生相当错误的地点,而MethodWithTry根本不驾驭产生错误的地点了。调用的堆栈倍重置了。假若这几个办法还设有此外的充裕,在UI层将永远不通晓真正产生错误的地点,给开发者带来非常大的艰苦。 

除了在建议59中涉嫌的内需包装格外的情形外,无故地嵌套非常是大家要尽力防止的。当然,假使真得需求捕获这些分外来苏醒部分场所,然后重新抛出,代码来起来应当能够这样:

            try
            {
                MethodWithTry();
            }
            catch(Exception)
            {
                ///工作代码
                throw;
            }

如故稍作改动

            try
            {
                MethodWithTry();
            }
            catch
            {
                ///工作代码
                throw;
            }

尽量制止上面那样吸引这个:

            try
            {
                MethodWithTry();
            }
            catch(Exception exception)
            {
                ///工作代码
                throw exception;
            }

向来throw exception而不是throw将会重置堆栈音信。

 

建议63、避免“吃掉”异常 

  看了建议62后头,你或许已经精通,嵌套非凡是很惊险的一举一动,一十分大心就会将不胜堆栈音讯,也等于实在的Bug出处隐藏起来。但那还不是最沉痛的作为,最严重的就是“吃掉”非常,即捕获然后不向上层throw抛出。

  制止“吃掉”至极,并不是说不应该“吃掉”非常,而是那之中有个第③原则:该越发可悲预知,并且普通状态它不能够算是一个Bug。

  想象你正在对上万份文件实行解密,那个文件来自分歧的客户端,很有大概存在文件倍破坏的情景,你的靶子正是要讲解密出来的多寡插入数据库。那个时候,你不得不忽略那1个解密败北的难题,让这一个进度进展下去。当然,记录日志是不可或缺的,
因为早先时期你或然会倍解密失利的文本做统一的处理。

  此外一种状态,恐怕连记录日志都不供给。在对上千个受控端举办支配的分布式系统中,控制端要求发送心跳多少来判断受控端的在线状态。经常的做法是维护3个信号量,假若在一个可承受的阻止时间如(如500ms)心跳数据发送失利,那么控制端线程将不会接收信号,即可以判明受控端的断线状态。在那种景况下,对每回SocketException进行记录,日常也是从未意思的。

  本提议的全部成分是:假诺你不知底什么样处理有些至极,那么相对不要“吃掉”至极,若是您一很大“吃掉”了一个相应网上传递的拾分,那么,那里或然诞生三个BUg,而且,化解它会很费周折。 

建议64、为循环扩张Tester-Doer格局而不是将try-catch置于循环内

  假设急需在循环中引发那多少个,你必要尤其注意,因为抛出相当是二个卓殊影响属性的进度。应该尽大概在循环个中对足够发生的一对尺度举办判断,然后依照规则进行处理。能够做一个测试:

        static void Main(string[] args)
        {
            CodeTimer.Initialize();

            CodeTimer.Time("try..catch..", 1, P1);

            CodeTimer.Time("Tester-Doer", 1, P2);

            Console.ReadLine();
        }

        public static void P1()
        {
            int x = 0;
            for (int i = 0; i < 1000; i++)
            {
                try
                {
                    int j = i / x;
                }
                catch
                { 

                }
            }
        }

图片 3

分化十一分醒目。以上代码中,大家预言了代码恐怕会时有产生DivideByZeroException相当,于是,调整策略,对那么些产生的准绳举行了特别处理:Continue,让作用得到了偌大的升官。

 

立陶宛共和国(Republic of Lithuania)语小贴士

1、 How much?—— 多少钱?
2、I’m full.—— 我饱了。
三 、 I’m home.—— 小编回去了。
④ 、 I’m lost. ——作者迷路了。
5、 My treat.—— 我请客。
陆 、 So do I.—— 小编也一样。
7、 This way.—— 这边请。
8、 After you.—— 您先。
9、 Bless you! ——祝福你!
10、 Follow me.—— 跟我来。

作者:aehyok

出处:http://www.cnblogs.com/aehyok/

谢谢您的读书,要是你对自笔者的博客所讲述的内容有趣味,那不妨点个推荐吧,多谢协理:-O。