设计模式(21) 状态模式

状态模式允许一个对象在其内部状态改变时改变它的行为。用电梯来举例，电梯可以认为具有开门、关门、运行、停止四种状态，这四种状态之间的切换具有多种限制，比如在开门状态下不电梯不能运行，只能转为关门状态；在运行状态下，电梯只能转为停止状态...
设想一下，如果要常规的if-else或者switch-case描述电梯的这几种状态间的切换，将生成非常复杂的、逻辑相互交织的代码，可读性差且不易维护。

而如果用状态模式来实现，会是怎样的呢？
首先创建LiftState，代表抽象的电梯状态，包含了电梯的四个动作（方法），通过这些方法可以切换到对应的状态。

public abstract class LiftState
{
    protected Context context;
    public void SetContext(Context context)
    {
        this.context = context;
    }

    public abstract void Open();
    public abstract void Close();
    public abstract void Run();
    public abstract void Stop();
}

Context是上下文类，它的作用是串联各个状态的过渡，在LiftSate抽象类中把Context类角色聚合进来，并传递到子类，这样4个具体的实现类中自己根据环境来决定如何进行状态的过渡。

public class Context
{
    public readonly static OpenningState openningState = new OpenningState();
    public readonly static ClosingState closingState = new ClosingState();
    public readonly static RunningState runningState = new RunningState();
    public readonly static StoppingState stoppingState = new StoppingState();

    private LiftState liftState;
    public LiftState LiftState
    {
        get
        {
            return liftState;
        }
        set
        {
            liftState = value;
            liftState.SetContext(this);
        }
    }

    public void Open()
    {
        this.liftState.Open();
    }
    public void Close()
    {
        this.liftState.Close();
    }
    public void Run()
    {
        this.liftState.Run();
    }
    public void Stop()
    {
        this.liftState.Stop();
    }
}

接下来是四个具体的状态类，负责状态之间的切换和控制，以OpenningState为例，只能切换到Closing状态，其它切换状态的方法都是空实现。

public class OpenningState : LiftState
{
    public override void Close()
    {
        base.context.LiftState = Context.closingState;
        base.context.LiftState.Close();
    }

    public override void Open()
    {
        Console.WriteLine("Openning");
    }

    public override void Run()
    {
        //
    }

    public override void Stop()
    {
        //
    }
}
public class ClosingState : LiftState
{
    public override void Close()
    {
        Console.WriteLine("Closing");
    }

    public override void Open()
    {
        base.context.LiftState = Context.openningState;
        base.context.LiftState.Open();
    }

    public override void Run()
    {
        base.context.LiftState = Context.runningState;
        base.context.LiftState.Run();
    }

    public override void Stop()
    {
        base.context.LiftState = Context.stoppingState;
        base.context.LiftState.Stop();
    }
}

public class RunningState : LiftState
{
    public override void Close()
    {
//
    }

    public override void Open()
    {
//
    }

    public override void Run()
    {
        Console.WriteLine("Running");
    }

    public override void Stop()
    {
        base.context.LiftState = Context.stoppingState;
        base.context.LiftState.Stop();
    }
}
public class StoppingState : LiftState
{
    public override void Close()
    {
        //
    }

    public override void Open()
    {
        base.context.LiftState = Context.openningState;
        base.context.LiftState.Open();
    }

    public override void Run()
    {
        base.context.LiftState = Context.runningState;
        base.context.LiftState.Run();
    }

    public override void Stop()
    {
        Console.WriteLine("Stopping");
    }
}

状态模式

通过上面的例子可以直观得看到状态模式的特点，它的核心是封装，状态的变更引起了行为的变更，从外部看起来就好像这个对象对应的类发生了改变一样。
GOF对状态模式的描述为：
Allow an object to alter its behavior when its internal state changes. The object will appear to change its class.
— Design Patterns : Elements of Reusable Object-Oriented Software

状态模式的UML类图为

状态模式中有3个角色：

• State（抽象状态角色），接口或抽象类，负责对象状态定义，并且封装环境角色以实现状态切换。
• ConcreteState（具体状态角色），每一个具体状态必须完成两个职责：就是本状态下要做的事情，以及本状态如何过渡到其他状态。
• Context（环境角色），定义客户端需要的接口，并且负责具体状态的切换。

状态模式的通用的代码

public abstract class State
{
    protected Context context;

    public void SetState(Context context)
    {
        this.context = context;
    }

    public abstract void Handle1();
    public abstract void Handle2();
}

public class ConcreteState1 : State
{
    public override void Handle1()
    {
        //本状态下必须处理的逻辑
    }

    public override void Handle2()
    {
        base.context.CurrentState = Context.STATE2;
        base.context.Handle2();
    }
}

public class ConcreteState2 : State
{
    public override void Handle1()
    {
        base.context.CurrentState = Context.STATE1;
        base.context.Handle1();
    }

    public override void Handle2()
    {
        //本状态下必须处理的逻辑
    }
}

public class Context
{
    public readonly static State STATE1 = new ConcreteState1();
    public readonly static State STATE2 = new ConcreteState2();

    private State currentState;
    public State CurrentState
    {
        get
        {
            return currentState;
        }
        set
        {
            this.currentState = value;
            this.currentState.SetState(this);
        }
    }

    public void Handle1()
    {
        this.CurrentState.Handle1();
    }

    public void Handle2()
    {
        this.CurrentState.Handle2();
    }
}

关于Context类，通常的做法是把状态对象声明为静态常量，有几个状态对象就声明几个静态常量。而且环境角色具有状态抽象角色定义的所有行为，具体执行使用委托方式。

调用端代码：

public class Test
{
    public static void Entry()
    {
        Context context = new Context();
        context.CurrentState = Context.STATE1;
        context.Handle1();
        context.Handle2();
    }
}

状态模式的优缺点

优点

• 结构清晰，避免了过多的switch...case或者if...else语句的使用，降低了程序的复杂性,提高系统的可维护性。
• 遵循设计原则，很好地体现了开闭原则和单一职责原则，每个状态都是一个子类，增加状态就要增加子类，修改状态则只需要修改对应的子类。
• 封装性非常好，这也是状态模式的基本要求，状态变换放置到类的内部来实现，外部的调用不用知道类内部如何实现状态和行为的变换。

缺点
状态模式主要的缺点在于，随着状态的增加，子类会变得太多。

状态模式的适用场景

• 行为需要随状态的改变而改变时
• 业务逻辑比较复杂，导致程序中大量使用了switch或者if语句，为了避免程序结构不清晰，逻辑混乱，可以使用状态模式来重构，通过扩展子类来实现了条件的判断处理。
• 另外，使用整体模式也需要注意避免滥用，只有当某个对象在它的状态发生改变时，它的行为也随着发生比较大的变化时，才考虑用状态模式，而且对象的状态最好不要超过5个。

参考书籍：
王翔著 《设计模式——基于C#的工程化实现及扩展》