有一对夫妇的解决方案，浮现在脑海中，将允许一个完全坚实的解决方案。

溶液1

满足依赖反转原则的第一个也是最简单的方法是将Run类注入到Walk类中，如下所示：

public class Walk : IState
{
    float speed = 10;
    private readonly IState _runState;
    public Walk(IState runState)
    {
        _runState = runState;
    }

    public IState CheckForState()
    {
        if (speed > 5)
        {
            return _runState;
        }
        return this;
    }
}

这个解决方案使得Walk不再依赖于Run的具体实现，但仍然允许它转换到运行状态。然而，这确实要求Walk知道它可以转换到哪个状态（我认为这是一个合理的期望）。

溶液2

您可以通过将状态转换表示为对象来进一步分离这一点。

public interface IState
{
    public IState CheckForState();
    public float Value {get;}
}

public interface IStateTransition
{
    public IState CheckTransition(IState source);
}

public class GreaterThanTransition : IStateTransition
{
    private readonly IState _targetState;
    private readonly int _checkValue;

    public GreaterThanTransition(IState targetState, int checkValue)
    {
        _targetState = targetState;
        _checkValue = checkValue;
    }
    public IState CheckTransition(IState sourceState) => sourceState.Value > _checkValue ? _targetState : sourceState;
}

public class Walk : IState
{
    private readonly List<IStateTransition> _transitions;

    public Walk(List<IStateTransition> transitions)
    {
        _transitions = transitions;
    }
    public float Value => 10;

    public IState CheckForState() => _transitions.Select(t => t.CheckTransition(this)).FirstOrDefault(s => s != this) ?? this;
}

然后可以创建一个Walk示例，如下所示：

new Walk(new List<IStateTransition>
{
    new GreaterThanTransition(new Run(...), 5)
});

这要求可以在IStateTransition中使用state对象中的值来检查是否需要发生状态转换。我在示例中使用了int作为Value属性的类型，但您可以轻松地将其切换为泛型类型。
这种解决方案完全分离了每个状态，并将状态转换捕获为可重用组件。由于代码现在被分割到更多的类和接口，因此在某些方面更加复杂，但它也完全融入了SOLID原则。