定义

1. 当一个对象的内在状态改变时，允许其行为，这个对象看起来像是改变了其类
2. 消除庞大的分支判断语句，将各个状态的逻辑分布在 State 的子类中，来减少相互依赖
3. 就是将特定状态相关的行为局部化，并将不同的状态分隔开来

使用场景

1. 当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑状态模式
2. 一个操作中包含庞大的分支结构，并且这些分支决定于对象的状态时

代码实现

//抽象的状态类
abstract class State
{
    public abstract void Handle(Context context);
}

//具体状态A
class ConcreteStateA: State
{
    public override void Handle(Context context)
    {
        context.State = new ConcreteStateB();
    }
}

//具体状态B
class ConcreteStateB: State
{
    public override void Handle(Context context)
    {
        context.State = new ConcreteStateA(); //设置下一个状态
    }
}

class Context
{
    private State state;
    

    public Context(State state)
    {
        this.state = state;
    }
    
    public State State
    {
        get {return state;}
        set { state = value; }
    }
    
    public void Request()
    {
        state.Handler(this);
    }

}

void Main()
{
    Context c = new Context();
    c.Request();
    c.Request();
    c.Request();
    c.Request();
}



//具体示例
   public abstract class Rate
    {
        public abstract void RateScore(Score score);
    }

    public class ExcellentRate : Rate
    {
        public override void RateScore(Score score)
        {
            if (score.MathScore == 100)
            {
                Console.WriteLine("满分");
            }
            else
            {
                score.Current = new GreatRate();
                score.RateScore();
            }
        }
    }
    
    public class GreatRate : Rate
    {
        public override void RateScore(Score score)
        {
            if (score.MathScore >= 80)
            {
                Console.WriteLine("优秀");
            }
            else
            {
                score.Current = new GoodRate();
                score.RateScore();
            }
        }
    }
    
    public class GoodRate : Rate
    {
        public override void RateScore(Score score)
        {
            if (score.MathScore >= 60)
            {
                Console.WriteLine("及格");
            }
            else
            {
                score.Current = new BadRate();
                score.RateScore();
            }
        }
    }
    
    public class BadRate : Rate
    {
        public override void RateScore(Score score)
        {
            if (score.MathScore < 60)
            {
                Console.WriteLine("不及格");
            }
        }
    }


    public class Score
    {
        private Rate current;
    
        public int MathScore { get; set; }
    
        public Score()
        {
            current = new ExcellentRate();
        }
    
        public Rate Current { get { return current; } set { current = value; } }
    
        public void RateScore()
        {
            current.RateScore(this);
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            Score score = new Score();
            score.MathScore = 100;
            score.RateScore();
            score.MathScore = 88;
            score.RateScore();
            score.MathScore = 70;
            score.RateScore();
            score.MathScore = 55;
            score.RateScore();
        }
    }

分析构成

1. 抽象状态，包含一个待实现的方法，参数是要判断的参数
2. 具体状态判断类，判断传递的参数是否合适，合适应该执行什么，不合适需要变化为哪个状态的判断，并执行跳转到下个状态判断类
3. Context 上下文类，用于处理状态的变化和执行跳转到不同的状态类。

4. 初始化中实例状态为第一个状态判断。

   1. 一个状态的属性，用于具体状态类中切换状态
   2. 一个判断值属性，用于具体状态类的判断逻辑
   3. 一个方法，该方法是抽象状态要实现的方法，也是进入下一个状态的方法

优缺点

1. 根据状态分隔，满足“单一职责原则”
2. 减少对象间相互依赖
3. 有利于程序的扩展，会增加类和对象的个数
4. 状态模式的结构和实现比较复杂，使用不当会导致程序结构和代码混乱