鸿 网 互 联 www.68idc.cn

当前位置 : 服务器租用 > .net技术 > c#编程 > >

重构手法之简化条件表达式【1】

来源:互联网 作者:佚名 时间:2018-02-06 13:39
返回总目录 本小节目录 Decompose Conditional(分解条件表达式) Consolidate Conditional Expression(合并条件表达式) 1Decompose Conditional(分解条件表达式) 概要 你有一个复杂的条件(if-else if-else)语句。 从if、else if、else三个段落中分别

返回总目录

本小节目录

  • Decompose Conditional(分解条件表达式)
  • Consolidate Conditional Expression(合并条件表达式)

1Decompose Conditional(分解条件表达式)

概要

你有一个复杂的条件(if-else if-else)语句。

从if、else if、else三个段落中分别提炼出独立函数。

动机

复杂的条件逻辑往往会导致程序复杂度上升。编写代码来检查不同的条件分支、根据不同的分支做不同的事往往又会导致函数过长。

将条件表达式分解为多个独立函数,根据每个小块代码的用途,为分解而得的新函数命名,并将原函数中对应的代码改为调用新建函数,从而更清楚地表达自己的意图。对于条件逻辑,将每个分支条件分解成新函数还可以突出条件逻辑,更清楚地表明每个分支的作用,并且突出每个分支的原因。

范例

假设要计算购买某样商品的总价,而这个商品在冬天和夏天的单价是不同的:

class Order
{
    public double Quantity { get; set; }

    public double WinterRate { get; set; }

    public double SummerRate { get; set; }

    public double WinterServiceCharge { get; set; }

    public double GetCharge(DateTime date)
    {
        double result;
        if (date.Month < 3 || date.Month > 6)
        {
            result = Quantity * WinterRate + WinterServiceCharge;
        }
        else
        {
            result = Quantity * SummerRate;
        }
        return result;
    }

}

现在把每个分支的判断条件都提炼到一个独立函数中:

class Order
{
    public double Quantity { get; set; }

    public double WinterRate { get; set; }

    public double SummerRate { get; set; }

    public double WinterServiceCharge { get; set; }


    public double GetCharge(DateTime date)
    {
        double result;
        if (NotSummer(date))
        {
            result = WinterCharge(Quantity);
        }
        else
        {
            result = SummerCharge(Quantity);
        }
        return result;
    }

    private bool NotSummer(DateTime date)
    {
        return date.Month < 3 || date.Month > 6;
    }
    private double SummerCharge(double quantity)
    {
        return quantity * SummerRate;
    }

    private double WinterCharge(double quantity)
    {
        return quantity * WinterRate + WinterServiceCharge;
    }
}

通过这段代码可看出整个重构带来的清晰性。

小结

像上面这样的情况,很多人都不会去提炼分支条件。因为这些分支条件往往非常短,看上去似乎没有提炼的必要。但是,尽管这些条件往往很短,在代码意图和代码自身之间往往存在不小的差距。就像上面那样,NotSummer(date)这个语句比原本的代码更好地表达自己的意图。原来的代码,我必须看看,想一想,才能说出其作用。当然了,这里看起来似乎很简单。即使是这样,提炼出来的函数可读性也更高一些。

2Consolidate Conditional Expression(合并条件表达式)

概要

你有一系列条件测试,都得到相同结果。

将这些测试合并为一个条件表达式,并将这个条件表达式提炼成为一个独立函数。

动机

代码里经常有这样的检查:检查条件各不相同,最终行为却一致。如果发现这种情况,应该使用“逻辑与”和“逻辑或”将它们合并为一个条件表达式。

之所以合并条件代码,有两个原因。(1)合并后的条件代码会告诉你“实际上只有一次条件检查,只不过有多个并列条件需要检查而已”,从而使这一次检查的用意更清晰。(2)这项重构往往是为了使用Extract Method做好准备。

范例:使用逻辑或

class Amount
{
    public int Seniority { get; set; }

    public int MonthsDisabled { get; set; }

    public bool IsPartTime { get; set; }

    double DisablilityAmount()
    {
        if (Seniority < 2)
        {
            return 0;
        }
        if (MonthsDisabled > 12)
        {
            return 0;
        }
        if (IsPartTime)
        {
            return 0;
        }
        //compute the disability amount
        //your code here
        return 1;
    }
}

这段代码中,一连串的条件检查都在做同一件事情。对于这样的代码,上述检查等价于一个以逻辑或连接起来的语句:

class Amount
{
    public int Seniority { get; set; }

    public int MonthsDisabled { get; set; }

    public bool IsPartTime { get; set; }

    double DisablilityAmount()
    {
        if (Seniority < 2 || MonthsDisabled > 12 || IsPartTime)
        {
            return 0;
        }
        //compute the disability amount
        //your code here
        return 1;
    }
}

现在,我们观察这个新的条件表达式,并运用Extract Method将它提炼成一个独立函数,以函数名称表达该语句所检查的条件:

class Amount
{
    public int Seniority { get; set; }

    public int MonthsDisabled { get; set; }

    public bool IsPartTime { get; set; }

    double DisablilityAmount()
    {
        if (IsNotEligibleForDisability())
        {
            return 0;
        }
        //compute the disability amount
        //your code here
        return 1;
    }

    bool IsNotEligibleForDisability()
    {
        return Seniority < 2 || MonthsDisabled > 12 || IsPartTime;
    }
}

范例:使用逻辑与

class Rate
{
    public double GetRate()
    {
        if (OnVacation())
        {
            if (LengthOfService() > 10)
            {
                return 1;
            }
        }
        return 0.5;
    }
    private bool OnVacation()
    {
        return true;
    }
    private int LengthOfService()
    {
        return 9;
    }
}

这段代码可以变成这样:

class Rate
{
    public double GetRate()
    {
        if (OnVacation() && LengthOfService() > 10)
        {
            return 1;
        }
        return 0.5;
    }
    private bool OnVacation()
    {
        return true;
    }
    private int LengthOfService()
    {
        return 9;
    }
}

如果所观察的部分只是对条件进行检查并返回一个值,就可以使用三元操作符将这一部分变成一条return语句。因此,下列代码:

if (OnVacation() && LengthOfService() > 10)
{
    return 1;
}
return 0.5;

就变成了:

return (OnVacation() && LengthOfService() > 1) ? 1 : 0.5;

小结

那我们什么时候不需要合并表达式呢?

即我们认为这些检查的确彼此独立,的确不应该被视为同一次检查,那就不使用本项重构。

 

 

To Be Continued...

网友评论
<