结构化编程的三重境界：见山不是山：正确但冗余的逻辑

因此我们了解到，我们需要更加精确的判断时间的界限。因此我们重新将代码改为如下：

 

 

static void Main(string[] args)
{

    DateTime indate = new DateTime(2008, 9, 30);                    //入住时间
    DateTime outdate = new DateTime(2008, 10, 5, 12, 15, 12);        //退房时间
    double days = (outdate - indate).Days;                        //计算入住了几天

    if (outdate.Hour <= 11)                                    //这个时间段是 0:0:0到11:59:59
    {
        days += 0;                                            //当天不计算房费
    }
    else
    {                            //如果小时部分的值是12，且其的分秒部分的值都是0，就是12点整
        if (outdate.Hour == 12 && outdate.Minute == 0 && outdate.Second == 0) 
        {
            days += 0;                                        //当天也不计算房费
        }
        else//12:0:0以后
        {
            if (outdate.Hour <= 17)                                //时间段为 12:0:1到17:59:59
            {
                days += 0.5;                                    //加收半天房费
            }
            else                                            //18点之后
            {                        //如果小时部分的值是18，且其的分秒部分的值都是0，就是18点整                                                
                if (outdate.Hour == 18 && outdate.Minute == 0 && outdate.Second == 0) 
                {
                    days += 0.5;                            //加收半天房费
                }
                else
                {//18点之后
                    days++;                                //加收一天房费
                }
            }
        }
    }
    System.Console.WriteLine("你的入住结算信息\n入住时间{0}\n退房时间{1}\n一共入住了{2}天", indate, outdate, days);
}

 

上述的代码，使用了4个条件的嵌套判断，将退房的时间作了精确的判断（考虑到了分秒的临界点），同时初学的人员再次要了解到注释的重要性，以上的逻辑，如果不描写注释，估计过一个月后，你自己都不知道自己在干什么了。

现在我们运行程序，设定以下的时间段

 

DateTime indate = new DateTime(2008, 9, 30);                    //入住时间
DateTime outdate = new DateTime(2008, 10, 5, 12, 15, 12);        //退房时间

 

我们程序的运行结果得到了我们乐于见到的5.5天

 

结构化编程，还有一个重要的概念就是模块化，我们上面的代码中对整点的判断。比如12点整

outdate.Hour == 12 && outdate.Minute == 0 && outdate.Second == 0

和18点整

outdate.Hour == 18 && outdate.Minute == 0 && outdate.Second == 0

完全可以函数化，因此我们需要添加一个函数模块。

 

 

/// <summary>
/// 判断给定的时间是否是一个整时
/// </summary>
/// <param name="date">需要判断的时间</param>
/// <returns>如果是整时，则返回true，否则返回false</returns>
static bool IsZeroTime(DateTime date)
{
    if (date.Minute == 0 && date.Second == 0)//如果给定的时间的分秒值都是0
    {
        return true;
    }
    else
    {
        return false;
    }
}

 

我们新编写的IsZeroTime将判断整时的问题进行了函数（模块）化，不过初学的人要注意一点，如果一个if else 中仅处理一个问题的时候，我们完全可以优化成如下代码

 

 

/// <summary>
/// 判断给定的时间是否是一个整时
/// </summary>
/// <param name="date">需要判断的时间</param>
/// <returns>如果是整时，则返回true，否则返回false</returns>
static bool IsZeroTime(DateTime date)
{
    return date.Minute == 0 && date.Second == 0;
}

 

现在我们再来修改原先的逻辑主体的代码为：

 

static void Main(string[] args)
{

    DateTime indate = new DateTime(2008, 9, 30);                //入住时间
    DateTime outdate = new DateTime(2008, 10, 5, 12, 15, 12);    //退房时间
    double days = (outdate - indate).Days;                    //计算入住了几天

    if (outdate.Hour <= 11)                                //这个时间段是 0:0:0到11:59:59
    {
        days += 0;                                        //当天不计算房费
    }
    else
    {
        if (outdate.Hour == 12 && IsZeroTime(outdate))            //如果是12点整
        {
            days += 0;                                    //当天也不计算房费
        }
        else//12:0:0以后
        {
            if (outdate.Hour <= 17)                            //时间段为 12:0:1到17:59:59
            {
                days += 0.5;                                //加收半天房费
            }
            else
            { //18点之后
                if (outdate.Hour == 18 && IsZeroTime(outdate))    //如果是18点整
                {
                    days += 0.5;                            //加收半天房费
                }
                else
                {                                        //18点之后
                    days++;                                //加收一天房费
                }
            }
        }
    }
    System.Console.WriteLine("你的入住结算信息\n入住时间{0}\n退房时间{1}\n一共入住了{2}天", indate, outdate, days);
}

以上代码使用了IsZeroTime函数，让代码的表现能力更强更优雅。那现在是不是万事大吉呢了？我们现在看看以下的时间：

DateTime indate = new DateTime(2008, 10, 5, 2, 12, 0);//入住时间

DateTime outdate = new DateTime(2008, 10, 5, 12, 0, 0);//退房时间

我们的程序告诉我们，顾客住了0天！！！

 

而以下的日期

DateTime indate = new DateTime(2008, 10, 5, 19, 12, 0);                                                        //入住时间

DateTime outdate = new DateTime(2008, 10, 5, 19, 13, 0);                                            //退房时间

我们的程序告诉我们，顾客住了1天！！！

 

啊，那是多么不公平的事情啊，一个住了近10个小时的人计算机竟然说他可以免费，而另一个住了才1分钟的顾客，竟然要支付整整一天的房价！

问题出在哪里呢？如果你仔细想想，就可以猜到，我们一开始的计算也许就错了。

double days = (outdate - indate).Days;                                                                       //计算入住了几天

原来这个Days不是计算过了几个晚上，而是两个时间的间隔，该间隔用纳秒来计算出。所以我们要使用差值来计算用户是不是过夜的话，不能简单的进行相减。不过如果我们使用些技巧就可以来解决，比如我们把两个时间都切换到午夜时间（就是午夜凶铃那个电话铃响的时间，0:0:0），那么就可以计算机出用户是否过夜了。

double days = (outdate.Date - indate.Date).Days;                                                    //计算入住了几天

这样的话，只要顾客不是同天退房，就会得到大于0的值，如果值是0就表示用户是同天退房的。如果用户是隔夜退房的，我们的逻辑计算照旧，否则要看看用户住的时间是否超过半天。这样才合理嘛。

所以，我们需要把代码作些小的调正，先判断下顾客是否同天退房，如果是同天退房的话，计算他入住了几个小时：超过12小时算一天，否则算半天；如果顾客是隔天退房，那还继续保持我们原有的逻辑处理。

 

static void Main(string[] args)
{

    DateTime indate = new DateTime(2008, 10, 5, 19, 12, 0);        //入住时间
    DateTime outdate = new DateTime(2008, 10, 5, 19, 13, 0);        //退房时间

    double days = (outdate.Date - indate.Date).Days;            //计算入住了几天

    if (days == 0)
    {                                                //同天退房
        if ((outdate - indate).TotalHours <= 12)                //入住时间不超过12小时
        {
            days += 0.5;                                    //以半天房费计算
        }
        else                                            //超过12小时
        {
            days++;                                    //计算一天的房费
        }
    }
    else
    {                                                //隔夜退房

        if (outdate.Hour <= 11)                            //这个时间段是 0:0:0到11:59:59
        {
            days += 0;                                    //当天不计算房费
        }
        else
        {
            if (outdate.Hour == 12 && IsZeroTime(outdate))        //如果是12点整
            {
                days += 0;                                //当天也不计算房费
            }
            else                                        //12:0:0以后
            {
                if (outdate.Hour <= 17)                        //时间段为 12:0:1到17:59:59
                {
                    days += 0.5;                            //加收半天房费
                }
                else
                {                                         //18点之后
                    if (outdate.Hour == 18 && IsZeroTime(outdate))    //如果是18点整
                    {
                        days += 0.5;                        //加收半天房费
                    }
                    else
                    {                                    //18点之后
                        days++;//加收一天房费
                    }
                }
            }
        }
    }
    System.Console.WriteLine("你的入住结算信息\n入住时间{0}\n退房时间{1}\n一共入住了{2}天", indate, outdate, days);
}

现在我们可以处理同天退房和隔夜退房的不同逻辑了，我们可以看到，通过精确的控制，我们的代码可处理的能力越来越强大，不过代码也越来越复杂了，嵌套也越来越庞大。因此，我们开始反思，为了追求正确的逻辑，我们是不是走了太远了？