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

Question

I am trying to get into C# generics and have created a state machine with the state pattern and now I try to refactor.

I have a state, which has a reference to the object it's working on.

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

    protected T statefulObject;

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

}

and I have the object which has states, this should have a reference to its current state.

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

    public T state;

}

But it does not work ("the type cannot be used as type parameter 't' in the generic type or method").

What I want to achieve is something like this :

public class Monster : StatefulObject<MonsterState> {

}

public abstract class MonsterState : AbstractState<Monster> {

}

Is this possible? If it's not this way, is there another? Thx.

Answer 1

You can abuse interfaces and variance to achieve that:

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)
    {
    }
}

Whether it's actually a good idea is dubious, such code may be too confusing.

---

You could also go with the simpler (but less strongly-typed) approach:

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)
    {
    }
}

This won't ensure you won't be able to assign, say a PlayerState to a Monster , you should check that at runtime.