C＃泛型，状态模式的交叉引用类

杜杜力诺

我试图进入C＃泛型，并使用状态模式创建了一个状态机，现在我尝试进行重构。

我有一个状态，该状态引用了它正在处理的对象。

public abstract class AbstractState<T> where T : StatefulObject {

    protected T statefulObject;

    public AbstractState(T statefulObject) {
        this.statefulObject = statefulObject;
    }

}

并且我有具有状态的对象，这应该引用其当前状态。

public abstract class StatefulObject<T> : MonoBehaviour where T : AbstractState<StatefulObject<T>> {

    public T state;

}

但这是行不通的（“该类型不能在通用类型或方法中用作类型参数't'”）。

我想要实现的是这样的：

public class Monster : StatefulObject<MonsterState> {

}

public abstract class MonsterState : AbstractState<Monster> {

}

这可能吗？如果不是这样，还有其他吗？谢谢。

卢卡斯（Lucas Trzesniewski）

您可以滥用接口和差异来实现以下目的：

public interface IState<out TObject, in TState>
    where TObject : IStatefulObject<TObject, TState>
    where TState : IState<TObject, TState>
{
}

public interface IStatefulObject<in TObject, out TState>
    where TObject : IStatefulObject<TObject, TState>
    where TState : IState<TObject, TState>
{
}

public abstract class AbstractState<TObject> : IState<TObject, AbstractState<TObject>>
    where TObject : IStatefulObject<TObject, AbstractState<TObject>>
{
    protected TObject Object { get; private set; }

    public AbstractState(TObject obj)
    {
        Object = obj;
    }
}

public abstract class StatefulObject<TState> : IStatefulObject<StatefulObject<TState>, TState>
    where TState : IState<StatefulObject<TState>, TState>
{
    protected TState State { get; set; }
}

public class Monster : StatefulObject<MonsterState>
{
    public Monster()
    {
        State = new IdleMonsterState(this);
    }
}

public abstract class MonsterState : AbstractState<Monster>
{
    protected MonsterState(Monster monster)
        : base(monster)
    {
    }
}

public class IdleMonsterState : MonsterState
{
    public IdleMonsterState(Monster monster)
        : base(monster)
    {
    }
}

不管它实际上是一个好主意还是令人怀疑的，这样的代码可能太令人困惑了。

您还可以使用更简单（但类型不那么强）的方法：

public abstract class AbstractState
{
}

public abstract class StatefulObject
{
}

public abstract class AbstractState<TObject> : AbstractState
    where TObject : StatefulObject
{
    protected TObject Object { get; private set; }

    public AbstractState(TObject obj)
    {
        Object = obj;
    }
}

public abstract class StatefulObject<TState> : StatefulObject
    where TState : AbstractState
{
    protected TState State { get; set; }
}

public class Monster : StatefulObject<MonsterState>
{
}

public abstract class MonsterState : AbstractState<Monster>
{
    protected MonsterState(Monster monster)
        : base(monster)
    {
    }
}

这不会确保您将无法分配，例如，PlayerState将a分配给，Monster则应在运行时检查。

本文收集自互联网，转载请注明来源。

如有侵权，请联系 [email protected] 删除。