软件实现技术课结课了，最终小组取得了第二名的成绩。

这门课，是由软微学院和微软联合创办的课程，虽然开始选这门课的时候，更多的是看重的微软的这个名字。不过学完之后看过来，的确学到了一些很有用的东西，受益匪浅。

总结一下：

• Learning by Doing
  通过实践来学习，掌握技能和技巧。要努力提高自己遇到问题解决问题的能力。
• 算法设计要提到一个非常高的重视程度
  尽管在开发时，架构、框架、管理……一切都很重要，但是算法绝对不可以忽视，有了足够好的算法，系统才能更加稳定更加健壮，也更加完善地运行
  加强自己的算法设计能力，通过研究算法，加强自己对操作系统的认识，提高逻辑思维能力
• 做就要做最好的
  在任何时候，能够被大家记住的，只有第一名。
  在参与竞争时，要给自己暗示：只有两个名次，要么做第一名，要么做除了第一名以外的并列最后一名。
  我们都记得神五飞船杨利伟的名字，可是又有多少人还能马上叫出的神六的两位航天员的名字呢？
• 向比自己做的好的人和团队借鉴经验
  正所谓踏在巨人的肩膀上前进，这样才能事倍功半
• 各自在团队中扮演好自己的角色，做出自己应有的贡献
  没有PM的组织，团队是一团散沙；没有Dev的辛勤开发，系统无法运行；没有Test的认真测试，系统正确性无法保证。三足鼎立，就像三角形，缺一角，就变得不够稳定了。
• Nothing is impossible
  没有什么是做不到的，只要你想，并且为之付出足够的努力

我组的PM杰哥，获得了整个课程的最佳PM奖，恭喜杰哥！没有他，小组的沟通与进度便无法保证，大家也不会如此重视。

最后，欢迎各位去我的Blog：http://www.techwork.cn/

--- Paul

软件实现技术（补）第十四次课

      7月25日本周五是补上周日这门课的第十四次课，微软的工程师对我们这门课的大作业“嵩山项目”进行讲评。我们前6各小组做的都是电梯的小项目由一位老师进行讲评；后面6个小组做了3个小项目，包括电梯、自动售货机和汽车，由一位老师进行讲评。老师在讲个过程中主要是讲了每个小组代码的优点以及需要改进的地方。

我们小组的情况是：

优点：1、面向对象的意图很明显，使用多个类协同完成；

         2、大量大小函数的内聚比较好；

         3、采用模块化，各模块具有很强的独立性，容易维护和升级。

需要改进的地方：

        1、用死循环查询（设置）电梯状态。在电梯等待或者空闲状态也会一直在扫描电梯的状态，有一定的浪费；

        2、命名规则前后不一致；

        3、有些函数和变量名字起的不恰当；

        4、缺少必要的错误检查处理；

        5、有些方法可以改为C#的属性。

      以上这些就是我们小组的情况。需要改进的地方，第一，我们将电梯状态查询/设置的算法可以细化到根据某些状态需要每次都扫描，有些状态不需要扫描例如空闲和停止状态，但是可以有一个状态激活，如果这两个状态改变了就要每次都进行扫描。第二，在开发过程中两名开发人员的编码习惯有一定的不同，在编码完成后应该让开发小组负责人进行代码审核。

     感谢老师在繁忙的工作中抽时间对我们代码的评审！

最近将一个项目的数据库由SQL Server 2000迁移到了2005，而在这过程中出现了一点点问题，特总结如下：

1、如何找到SQL Server 2005 的 JDBC 驱动？
http://www.microsoft.com/downloads/details.aspx?displaylang=zh-cn&FamilyID=6d483869-816a-44cb-9787-a866235efc7c

2、如果管理SQL Server 2005?
使用SQL Server Management Studio：http://www.microsoft.com/downloads/details.aspx?displaylang=zh-cn&FamilyID=c243a5ae-4bd1-4e3d-94b8-5a0f62bf7796#filelist

3、如何设置SQL Server 服务器？
(1). 打开SQL Server Configuration Manager -> MSSQLSERVER的协议 -> TCP/IP
(2). 右键单击启动TCP/IP
(3). 双击进入属性,把IP地址中的IP all中的TCP端口设置为1433
(4). 重新启动SQL Server 2005服务中的MSSQLSERVER服务器
(5). 关闭SQL Server Configuration Manager
(6). 现在就可以使用1433端口通过TCP/IP协议访问SQL Server 2005了

4、原来是SQL Server 2000的程序，为什么转移到2005中连接不了了？
(1). 加载的驱动不同了，SQL Server 2005的JDBC驱动JAR包为：sqljdbc.jar，原来的则有三个。
(2). JAR包的类名和连接字符串不同了。在SQL Server 2000 中加载驱动和URL路径的语句是
      String driverName = "com.microsoft.jdbc.sqlserver.SQLServerDriver";
      String dbURL = "jdbc:microsoft:sqlserver://localhost:1433; DatabaseName=sample";
      而SQL Server 2005 中加载驱动和url的语句则为
      String driverName = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
      String dbURL = "jdbc:sqlserver://localhost:1433; DatabaseName=sample";
      这里需要十分注意。
(3). 经过上述修改，便可以正确连接SQL Server 2005

今天是代码分析的最后一部分：最关键的四个函数。

从最简单的说起吧。

/// <summary>
/// 运行到某层时检查是否需要停下
/// </summary>
/// <param name="floor"></param>
/// <param name="direction"></param>
/// <returns></returns>
protected bool NeedStop(int floor, Direction direction)
{
    if (_stopfloors.ContainsKey(floor))
    {
        _stopfloors.Remove(floor);
        _task.NeedStop(floor, direction);
        return true;
    }
    else if (_task.NeedStop(floor, direction))
    {
        return true;
    }
    else
    {
        return false;
    }
}

NeedStop()函数判断了在某层、某方向上是否需要停止。在判断的时候，我们需要考虑外部呼梯和内部呼梯两种情况；同时，如果可以停，那么还不能忘记了把相关的层数从相关的列表中去除，也就是马上要停到该层，该层的呼梯任务完成。而在检查外部呼梯的过程中，直接调用了Task类已经写好的同名函数NeedStop()，大家也可以看我们曾经的日志来检查那个函数的写法。

/// <summary>
/// 检查是否还有同方向上更多的层需要经停
/// </summary>
/// <param name="floor"></param>
/// <param name="direction"></param>
/// <returns></returns>
protected bool ContainsMore(int floor, Direction direction)
{
    switch (direction)
    {
        case Direction.up:
            //首先检查内部呼梯
            for (int i = 0; i < _stopfloors.Count; i++)
            {
                if (floor < _stopfloors.Keys[i])
                {
                    return true;
                }
            }
            //再检查外部呼梯
            if (_task.ContainsMore(floor, direction))
            {
                return true;
            }
            break;
        case Direction.down:
            //首先检查内部呼梯
            for (int i = 0; i < _stopfloors.Count; i++)
            {
                if (floor > _stopfloors.Keys[i])
                {
                    return true;
                }
            }
            //再检查外部呼梯
            if (_task.ContainsMore(floor, direction))
            {
                return true;
            }
            break;
        case Direction.none:
            break;
    }

    return false;
}

ContainsMore()这个函数主要是判断电梯是否需要继续上行。例如，电梯在3层，5层有个向下呼梯。那么到了5层，电梯便可以转变方向而不用再上到六层。同样，这个函数也需要分别检查内部呼梯和外部呼梯两个列表，而在调用外部呼梯的检查过程时使用了Task类的同名函数。

下一个函数是FindDirection()，判断电梯的运行方向。这个过长会发生在stopping阶段。判断电梯下一步的运行方向如何。大家看了程序就很容易明白，因为代码注释写的很清楚了：

/// <summary>
/// 判断电梯下一步的运行方向
/// </summary>
/// <returns>电梯下一步要运动的方向</returns>
public Direction FindNextDirection()
{

    //如果外部呼梯和内部呼梯均没有内容，则原地待命
    if (_stopfloors.Count==0 && _task.ifEmpty())
    {
        return Direction.none;
    }

    //如果现在电梯处于上升或停止状态，那么判断本楼层以上是否还有呼梯
    if (_direction == Direction.none || _direction == Direction.up)
    {
        //如果还有未完成上行的任务
        if (ContainsMore(_floor.Current, Direction.up))
        {
            return Direction.up;
        }
        //如果还有未完成下行的任务
        else if (ContainsMore(_floor.Current, Direction.down))
        {
            return Direction.down;
        }
    }
    else if(_direction == Direction.down)
    {
        //如果还有未完成下行的任务
        if (ContainsMore(_floor.Current, Direction.down))
        {
            return Direction.down;
        }
        //如果还有未完成上行的任务
        else if (ContainsMore(_floor.Current, Direction.up))
        {
            return Direction.up;
        }
    }

    return Direction.none;
}

最后就是最重要的RefreshStatus()函数了。它为电梯状态改变，提供了转换及其发生的相关条件判断。

/// <summary>
/// 刷新运行状态
/// </summary>
protected void RefreshStatus()
{
    while (_runinngPermit)
    {
        int ticks = Environment.TickCount;
        int activetime = ticks - _lastactive;

        switch (_status)
        {
            case Status.Out_of_Services:
                //如果电梯处在不可用状态，那么不予请求，直到电梯开启使用
                break;
            case Status.Maintenance:
                //如果电梯处在维护状态，那么不予请求
                break;
            case Status.Idle:
                //电梯处在空闲状态，此时如果有外部呼梯存在，或是内部请求存在，则决定前往的方向，将状态改变为上或下
                _direction = FindNextDirection();
                switch (_direction)
                {
                    case Direction.up:
                        _status = Status.Up;
                        break;
                    case Direction.down:
                        _status = Status.Down;
                        break;
                }
                break;
            case Status.Up:
                //电梯在上升的过程中，每5秒上升一层。在本层判断下一层是否是经停层。如果是，则将状态转化为停止。
                if (activetime < 2000)
                {
                    break;
                }
                else
                {
                    if (NeedStop(_floor.Current, _direction))
                    {
                        _status = Status.Stopping;
                    }
                    else
                    {
                        //如果到达顶层则向下
                        if (_floor.Current == _floor.getTopFloor())
                        {
                            _status = Status.Down;
                            _direction = Direction.down;
                        }
                        else
                        {
                            _floor.Up();
                        }
                    }
                    _lastactive = ticks;
                }
                break;
            case Status.Down:
                //电梯在下降的过程中，每2秒下降一层。在本层判断下一层是否是经停层。如果是，则将状态转化为开门。
                if (activetime < 2000)
                {
                    break;
                }
                else
                {
                    if (NeedStop(_floor.Current, _direction))
                    {
                        _status = Status.Stopping;
                    }
                    else
                    {
                        //如果到达底层则向上
                        if (_floor.Current == _floor.getBottomFloor())
                        {
                            _status = Status.Up;
                            _direction = Direction.up;
                        }
                        else
                        {
                            _floor.Down();
                        }
                    }
                    _lastactive = ticks;
                }
                break;
            case Status.Stopping:
                //电梯停止的过程中。这里判断下一步是继续上升还是下降
                if (activetime >= 2000)
                {
                    _status = Status.Opening;
                    _lastactive = ticks;
                }
                _direction = FindNextDirection();
                break;
            case Status.Opening:
                //电梯门打开，打开时间长3秒钟
                if (activetime >= 3000)
                {
                    _status = Status.Waiting;
                    _lastactive = ticks;
                }
                break;
            case Status.Waiting:
                //开门后，电梯停顿2秒，关门
                if (activetime >= 2000)
                {
                    _status = Status.Closing;
                    _lastactive = ticks;
                }
                break;
            case Status.Closing:
                //电梯门关闭，关闭时间长3秒钟
                if (activetime >= 3000)
                {
                    _status = Status.Idle;
                    _lastactive = ticks;
                }
                break;
        }

        StringBuilder status = new StringBuilder();
        status.AppendLine("Current Status:");
        status.AppendLine("Floor:" + _floor.Current + "  Direction:" + _direction + "  Status:" + _status);
        status.AppendLine();
        status.AppendLine("Outside Calls:");
        status.AppendLine(_task.ListAll());
        status.AppendLine("Inside Calls:");
        status.AppendLine(ListAllStopFloors());
        GetAllStatus(status.ToString());
        Console.WriteLine(status.ToString());
        Thread.Sleep(500);
    }
}

这段代码主要就是根据目前status状态，以及上一次系统活动的时间，来判断下一步电梯做什么，状态如何。有了上面很多关键函数的支撑，这里其实已经简化了很多，更多的都是周边的设置和输入输出工作了了。在正式运行时，我们激活了一个线程，每隔500毫秒执行一次本程序。最后，通过委托的挂接，将结果传送到高层模块中，以最终完成输出工作。

整个电梯的设计工作及代码分析到此结束了。在这一段日子里，我们通过这个程序，根据自己的需求和设计进行编码和实现，完成了电梯运行的再现。
最后一次的entry，将会展示我们电梯的测试类，并展示电梯的运行效果。

今天来主要分析电梯程序设计中最关键的类：ElevatorMain

首先贴出类的声明和它的字段列表：

/// <summary>
/// 电梯主类
/// </summary>
public class ElevatorMain
{
    /// <summary>
    /// 电梯外部呼梯任务
    /// </summary>
    private Task _task;
    /// <summary>
    /// 电梯内部经停任务
    /// </summary>
    private SortedList<int, int> _stopfloors;
    /// <summary>
    /// 电梯运行状态
    /// </summary>
    private Status _status;
    /// <summary>
    /// 电梯所有可以经停的楼层
    /// 以及现在所处的楼层
    /// </summary>
    private Floor _floor;
    /// <summary>
    /// 电梯运行的方向
    /// </summary>
    private Direction _direction;
    /// <summary>
    /// 最后一次系统活动时间
    /// </summary>
    private int _lastactive;

    //控制线程
    private Thread _running;
    //线程运行许可
    private bool _runinngPermit = true;

可以看出，我们的电梯程序中，主要用了如下字段：

• _task: 用来存储外部呼梯任务的Task对象
• _stopfloors: 保存内部电梯任务的对象，用SortedList<int,int>作为其载体
• _status: 存储电梯的各个运行状态
• _floor: 保存电梯想对应的层数信息，如当前层、层数列表等等
• _direction: 保存电梯运行的方向
• _lastactive: 存储上次电梯活动的时刻，用来计算电梯的运行时长来判断下一个任务的执行

有了这些相关类型数据的存储，就可以保证程序的顺利运行了。

/// <summary>
/// 电梯类构造函数
/// </summary>
/// <param name="floors">可以经停的楼层信息</param>
public ElevatorMain(Floor floor)
{
    _task = new Task();
    _stopfloors = new SortedList<int, int>();
    _floor = floor;
    _status = Status.Out_of_Services;
    _direction = Direction.none;
    _lastactive = Environment.TickCount;

    _running = new Thread(new ThreadStart(this.RefreshStatus));
    _running.Name = "Running";
    _running.Start();
}

上述函数是电梯运行的构造函数。将一些基本的数据初始化，还有就是新建一个线程，来运行RefreshStatus检测系统状态。这里使用了Polling轮询的方法，电梯实际运行中，应该会有一些触发的过程来处理。

/// <summary>
/// 开启电梯到运行状态
/// </summary>
public void Startup()
{
    if (_status == Status.Out_of_Services || _status == Status.Maintenance)
    {
        _status = Status.Idle;
    }
}

/// <summary>
/// 关闭电梯
/// </summary>
public void Closedown()
{
    if (_status == Status.Idle || _status == Status.Maintenance)
    {
        _status = Status.Out_of_Services;
    }
}

/// <summary>
/// 维修电梯
/// </summary>
public void Repair()
{
    if (_status == Status.Out_of_Services || _status == Status.Idle)
    {
        _status = Status.Maintenance;
    }
}

/// <summary>
/// 外部呼梯
/// </summary>
/// <param name="floor">楼层</param>
/// <param name="direction">方向</param>
public void Call(int floor, Direction direction)
{
    //如果电梯尚未运行则退出
    if (_status == Status.Out_of_Services || _status == Status.Maintenance)
    {
        return;
    }
    //如果没有这一层则退出
    if (!_floor.AllFloors.Contains(floor))
    {
        return;
    }
    //如果顶层按上行则退出
    if (floor == _floor.AllFloors[_floor.AllFloors.Count - 1] && direction == Direction.up)
    {
        return;
    }
    //如果底层按下行则退出
    if (floor == _floor.AllFloors[0] && direction == Direction.down)
    {
        return;
    }
    //增加任务
    _task.AddTask(floor, direction);
}

上述几个函数主要完成了电梯的开启、关闭、维修、外部呼梯过程。前几个较为简单，主要说下外部呼梯。其思想为：只有在电梯处于正常状态（非关闭、维护状态）才可以呼梯；不能在没有注册到电梯层数中的某层呼梯（比如电梯没有第4层，那么在第4层就不能呼梯）；最高层不能向上呼梯；最底层不能向下呼梯。

/// <summary>
/// 内部按键
/// </summary>
/// <param name="key">楼层号</param>
public void Click(int key)
{
    //如果电梯未运行则退出
    if (_status == Status.Out_of_Services || _status == Status.Maintenance)
    {
        return;
    }
    if (!_stopfloors.ContainsKey(key))
    {
        _stopfloors.Add(key, key);
    }
}

/// <summary>
/// 内部按键
/// </summary>
/// <param name="special_key">特殊按键</param>
public void Click(SpecialKeys special_key)
{
    if (_status == Status.Out_of_Services || _status == Status.Maintenance)
    {
        return;
    }
    switch (special_key)
    {
        case SpecialKeys.Alarm:
            _status = Status.Out_of_Services;
            break;
        case SpecialKeys.Call_Outside:
            // no use
            break;
        case SpecialKeys.Open_Door:
            if (_status == Status.Waiting)
            {
                //等待状态下按下开门
                _lastactive = Environment.TickCount;
            }
            else if (_status == Status.Closing)
            {
                //关门状态按下开门
                _lastactive = Environment.TickCount;
                _status = Status.Opening;
            }
            break;
        case SpecialKeys.Close_Door:
            if (_status == Status.Waiting)
            {
                //等待状态按下关门
                _lastactive = Environment.TickCount;
            }
            /*
            if (_status == Status.Opening)
            {
                //开门状态按下关门
                _lastactive = DateTime.Now.Ticks;
                _status = Status.Closing;
            }*/
            break;
    }
}

这两个函数是内部呼梯出发的函数。分为两个：一个是按普通的楼层按键，另一个则是按特殊按键。分别处理，重载函数，则可以显示程序的多态性。

/// <summary>
/// 取得到现在的运行状态
/// </summary>
/// <returns>当前运行状态</returns>
public Status GetCuurentStatus()
{
    return _status;
}

/// <summary>
/// 取得到当前的楼层号
/// </summary>
/// <returns>当前楼层号</returns>
public int GetCurrentFloor()
{
    return _floor.Current;
}

/// <summary>
/// 取得到电梯运行方向
/// </summary>
/// <returns>电梯当前运行方向</returns>
public Direction GetDirection()
{
    return _direction;
}

这三个函数即为取得到电梯当前运行状态的函数。通过它们，就可以准确判断电梯现在的状态了。

为了外部测试程序的调用，我又写了如下几个相关函数：

/// <summary>
/// 列出所有内部经停的层
/// </summary>
/// <returns></returns>
protected string ListAllStopFloors()
{
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < _stopfloors.Count; i++)
    {
        sb.AppendLine(_stopfloors.Keys[i].ToString() + "th floor");
    }
    return sb.ToString();
}

/// <summary>
/// 设置委托以便参数检查
/// </summary>
/// <param name="status"></param>
public delegate void GetAllStatusDelegate(string status);
/// <summary>
/// 设置事件
/// </summary>
public event GetAllStatusDelegate GetAllStatus;

public void StopRunning()
{
    _runinngPermit = false;
}

通过委托和事件的使用，就可以使外部的测试程序挂接到本类上，以取得到相关的输出更新。

到目前为止，程序已经介绍了大半部分，还剩下四个最为关键的函数。敬请期待。

今天这篇entry，主要来分析一下我们的Task类。这个类是一个非常关键的类，是存储外部呼梯的任务集合。正是这个类的存在，才使得我们的电梯程序能够支持多太电梯挂接。废话少说，请先看源代码：

/// <summary>
/// 外部呼梯任务集
/// </summary>
public class Task
{
    /// <summary>
    /// 上行列表
    /// </summary>
    private SortedList<int, int> _upList = new SortedList<int, int>();
    /// <summary>
    /// 下行列表
    /// </summary>
    private SortedList<int, int> _downList = new SortedList<int, int>();

    /// <summary>
    /// 添加一个新的任务
    /// </summary>
    /// <param name="floor">呼梯层号</param>
    /// <param name="direction">呼梯方向</param>
    public void AddTask(int floor, Direction direction)
    {
        switch (direction)
        {
            case Direction.up:
                if (!_upList.ContainsKey(floor)) //判断上升楼层是否已在队列
                    _upList.Add(floor, floor);
                break;

            case Direction.down:
                if (!_downList.ContainsKey(floor))//判断下降楼层是否已在队列
                    _downList.Add(floor, floor);
                break;
            case Direction.none:
                break;
        }
    }

    /// <summary>
    /// 判断是否没有上行或下行任务
    /// </summary>
    /// <returns></returns>
    public bool ifEmpty()
    {
        return (_upList.Count == 0 && _downList.Count == 0);
    }

    /// <summary>
    /// 判断本层后是否还有需要处理的楼层
    /// </summary>
    /// <param name="floor"></param>
    /// <param name="currentdirection"></param>
    /// <returns></returns>
    public bool ContainsMore(int currentfloor, Direction currentdirection)
    {
        switch (currentdirection)
        {
            case Direction.up:
                for (int i = 0; i < _upList.Keys.Count; i++)
                {
                    if (currentfloor < _upList.Keys[i])
                    {
                        return true;
                    }
                }
                for (int i = 0; i < _downList.Keys.Count; i++)
                {
                    if (currentfloor < _downList.Keys[i])
                    {
                        return true;
                    }
                }
                break;
            case Direction.down:
                for (int i = 0; i < _downList.Keys.Count; i++)
                {
                    if (currentfloor > _downList.Keys[i])
                    {
                        return true;
                    }
                }
                for (int i = 0; i < _upList.Keys.Count; i++)
                {
                    if (currentfloor > _upList.Keys[i])
                    {
                        return true;
                    }
                }
                break;
            case Direction.none:
                break;
        }
        return false;
    }

    /// <summary>
    /// 判断在某一层是否需要停止
    /// </summary>
    /// <param name="floor">楼层</param>
    /// <param name="direction">现方向</param>
    /// <returns></returns>
    public bool NeedStop(int floor, Direction direction)
    {
        switch (direction)
        {
            case Direction.up:
                if (_upList.ContainsKey(floor))
                {
                    _upList.Remove(floor);
                    return true;
                }
                break;
            case Direction.down:
                if (_downList.ContainsKey(floor))
                {
                    _downList.Remove(floor);
                    return true;
                }
                break;
            case Direction.none:
                break;
        }
        return false;
    }

    public string ListAll()
    {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < _upList.Count; i++)
        {
            sb.AppendLine(_upList.Keys[i].ToString() + " up");
        }
        for (int i = 0; i < _downList.Count; i++)
        {
            sb.AppendLine(_downList.Keys[i].ToString() + " down");
        }
        return sb.ToString();
    }

}

整个的类使用了两个SortedList来存储电梯呼梯任务：_upList和_downList，分别用来存储上行的任务和下行的任务。在设计的时候，我们曾经考虑过使用一个列表来保存。但是由于相对来讲，还是比较复杂的，所以就放弃了，决定吸收很多其他小组的优秀思想，改为了两个队列。

Task类中共有如下几个方法：

• AddTask() -- 添加一个新的任务
• ifEmpty() -- 判断是否有上行或下行任务，也就是列表中是否全空
• ContainsMore() -- 判断本层后是否还有需要处理的楼层
• NeedStop() -- 判断在某一层是否需要停止
• ListAll() -- 打印出现在的电梯呼梯任务，为测试提供输出。今后也可以作为电梯面板的显示而存在

当外部在某层按了某一个按钮后，系统就会相应AddTask()函数。当电梯由上行、下行准备停下时，也就是stopping的状态时，电梯要判断是否同方向上还有楼层需要处理。如果没有，那么则转向。ifEmpty函数在于判断列表是否为空，其对于整个电梯是否处于Idle空闲状态提供了判断一句。而电梯随着运行会插入一些中间的任务。所以我们判断在某层是否经停的时候，不可能在开始上升前就决定，而是到了某层后决定下层是否需要停。如果需要停，那么则转变为stopping状态减速，等待正常停止后开门。所以NeedStop()这个函数就提供了这样的一个功能。

其实这几个函数的实现并不是很难。相对而言，ContainsMore() 这个函数稍微复杂一些，判断在同方向上是否还有呼梯任务，那么就要遍历两个列表，还要分上行和下行两种情况。另外，在AddTask中，要判断这个任务是否已经进入了列表。如果已经呼梯了，那么也就没有必要再次加入了。

明天继续分析我们的项目，即将进入最关键的部分——ElevatorMain类

根据系统的设计，我们在Deadline之前完成了电梯的程序编码工作。在接下来的几天，我们组将和大家一起分享一下自己的编码和程序设计，和大家一起交流，也希望能够得到您的反馈和建议。

今天主要谈谈以下几个类或是枚举：

/// <summary>
/// 电梯运行的方向
/// 为了便于区分，放弃了使用bool类型变量转而使用枚举
/// </summary>
public enum Direction
{
    none,   //电梯停在某层的时候处于none状态
    up,
    down
}

以上是代表电梯运行方向的枚举。电梯不仅仅有向上和向下，还有处在停止、开门、关门等等的中间状态。
另外，电梯的运行方向和电梯的状态不完全是一回事。举个简单的例子：电梯停在一层，无任务；这个时候我们在一层按向上的呼梯按钮，电梯的运行方向会指向向上，但是电梯并没有处在往上走的过程中，而是在开门、等待、关门。所以，Direction和Elevator.Status，代表两个东西，不能等同存放。

/// <summary>
/// 电梯运行状态
/// 列举了电梯在其整个生命周期中的各个状态
/// </summary>
public enum Status
{
    Opening,    //正在开门中
    Waiting,    //开门后等待状态
    Closing,    //正在关门中
    Up,         //电梯上行中
    Down,       //电梯下行中
    Stopping,   //到达某层中即将停止前的减速状态
    Out_of_Services,    //电梯不可用
    Idle,       //无任务时的空闲状态
    Maintenance //维修状态
}

上述枚举列举了我们所认为的电梯所有可能处在的状态。我们把电梯的开门关门过程细化，分为了Stopping（电梯减速准备停止）、Opening（正在开门）、Waiting（等待进入乘客）、Closing（正在关门）这几种状态。而设置Stopping状态，一来可以代表电梯减速的过程，二来可以在这个时候判断电梯下一步的运行方向。在坐电梯的时候我们就会发现，下一步方向的判断是在电梯开门前。

/// <summary>
/// 特殊键位
/// 电梯内部的各个特殊键
/// 其它楼层数字键则用int型代替
/// </summary>
public enum SpecialKeys
{
    Open_Door,
    Close_Door,
    Alarm,
    Call_Outside
}

这个类定义了几个特殊按键。不同于几个其他组的设计，我们并没有把内部电梯按钮的层算进来算作Keys的枚举。因为我们认为电梯的层数应该是可以变化的，所以那一部分要独立出来响应相关的变化。

上述几个枚举虽然看起来并不难，但是却十分重要。它们决定了整个电梯的状态，也是体现电梯设计思想的第一步工作——分析好电梯运行流程。

1. 生活是不公平的，你要去适应它。
2. 这个世界并不会在意你的自尊，而是要求你在自我感觉良好之前先有所成就。
3. 刚从学校走出来时你不可能一个月挣4万美元，更不会成为哪家公司的副总裁，还拥有一部汽车，直到你将这些都挣到手的那一天。
4. 如果你认为学校里的老师过于严厉，那么等你有了老板再回头想一想。
5. 卖汉堡包并不会有损于你的尊严。你的祖父母对卖汉堡包有着不同的理解，他们称之为“机遇”。
6. 如果你陷入困境，那不是你父母的过错，不要将你理应承担的责任转嫁给他人，而要学着从中吸取教训。
7. 在你出生之前，你的父母并不像现在这样乏味。他们变成今天这个样子是因为这些年来一直在为你付账单、给你洗衣服。所以，在对父母喋喋不休之前，还是先去打扫一下你自己的屋子吧。
8. 你所在的学校也许已经不再分优等生和劣等生，但生活却并不如此。在某些学校已经没有了“不及格”的概念，学校会不断地给你机会让你进步，然而现实生活完全不是这样。
9. 走出学校后的生活不像在学校一样有学期之分，也没有暑假之说。没有几位老板乐于帮你发现自我，你必须依靠自己去完成。
10. 电视中的许多场景决不是真实的生活。在现实生活中，人们必须埋头做自己的工作，而非像电视里演的那样天天泡在咖啡馆里。
11. 善待你所厌恶的人，因为说不定哪一天你就会为这样的一个人工作。

本人正在某家美国的公司实习，常听到有人讲，你的工作太轻松了，中午12点多才到公司，都可以直接去吃饭了……

可他并不知道，12点之前，其实是在家办公的。

我现在的这家公司环境的确很好，这里的工作并不在乎工作的地点在哪里，工作的时间是几点，只要每天自己的任务都有进展，就可以了。早晨高峰去挤公共，路上堵的要命，对于员工，反而是在浪费时间。还不如在家先做些事情，等中午人少的时候再来公司。公司里很多同事也是如此，甚至有全职在家办公的。

这当然要求很高的自控能力和主动性。本人的自控能力并不好，所以经常半夜都会工作；但无论如何，本人在主动性方面还是很有信心的。

再想想看，如果工作真的太轻松了以至于每天都没什么事情做，是件好事情吗？

自己或许可以暗爽，但久而久之，自己学习和锻炼的机会也就没有了，在公司中的价值也就失去了。

公司会为没有价值的员工买单吗？

当然不会。

所以，要努力工作才行。

学习也是一样。

朋友 M 先生新买了一台 MacBook Pro，正巧他出差，先借来玩玩。

苹果笔记本的硬件外观和软件界面名不虚传，相当漂亮。

实用性方面……可能是我太习惯 Windows 了，所以 Mac 的操作方式还真不是很舒服。

鼠标就一个键，还无线的，沉就一个字，还不如触摸板还用。后来听另外一位朋友 J 先生说有右键的，不过要按住 Ctrl 再按鼠标，就是通常意义上的右键了。我倒。

输入法默认没有显示，要从系统设置里找出来。

新建帐户开始不知道怎么操作，到处都是灰的，半天才发现居然有个小小的锁型按钮，需要再次输入密码才可以继续操作。

不过总得而言，第一印象，这个“苹果”不是想象中的那么好吃。

赶紧装了个 VirtualBox，虚拟回 Windows。

前不久，朋友推荐给我一本书《小就是大》，书中共有154条改变事业和人生的商业妙想，如获至宝。

1. AAA 汽车配件公司

A 在电话簿中永远会排在第一位。前几年很多人在 QQ 昵称前加个空格也是这个道理。

2. 网络与责任

匿名本身就是礼貌的大敌。

3. 被感染的橡子

随着一名知识工人的技术水平不断提高，他用来积累知识的时间就会越来越长，而使用这些知识的时间却会越来越短。

写博客，可以用非常短的时间把想法传达给众多目标群体。这种作法的优势是相当明显的，不需要支付任何管理成本。

通过这种方式，不仅可以推动知识发展，还可以推动组织和本人不断取得进步。

立即动手，把想法告诉别人，互动起来吧。

……

This is a temporary post that was not deleted. Please delete this manually. (06fee68f-b292-4547-a5c8-117438af9854 - 3bfe001a-32de-4114-a6b4-4005b770f6d7)