从也继承自泛型单例的泛型类继承

Question

我在从一个泛型类继承时遇到了困难，而该泛型类本身是从一个泛型单例继承而来的。

我正在尝试创建一个作为单例的库存基类，并使用不同的派生项目从中派生不同的库存类型。

为简洁起见，代码已被简化。

public class Singleton<T> : MonoBehaviour where T : MonoBehaviour
{
    private static bool m_ShuttingDown = false;
    private static object m_Lock = new object();
    private static T m_Instance;

    public static T Instance
    {
        get
        {
            if (m_ShuttingDown)
                return null;
            lock (m_Lock)
            {
                if (m_Instance == null)
                {
                    m_Instance = (T)FindObjectOfType(typeof(T));    
                    if (m_Instance == null)
                    {
                        var singletonObject = new GameObject();
                        m_Instance = singletonObject.AddComponent<T>();
                        singletonObject.name = typeof(T).ToString() + " (Singleton)";

                        DontDestroyOnLoad(singletonObject);
                    }
                }    
                return m_Instance;
            }
        }
    }
    private void OnApplicationQuit()
    {
        m_ShuttingDown = true;
    }
    private void OnDestroy()
    {
        m_ShuttingDown = true;
    }
}

public class Inventory<T> : Singleton<Inventory<T>> where T : Item
{   
    ...
}
public class EquipmentInventory : Inventory<Equipment>
{
    ...
}
public class Item : ScriptableObject
{
    public string Name = "Item";
}
public class Equipment : Item
{
    public string Name = "Equipment";
}

我无法访问实例；

private EquipmentInventory equipmentInventory;
private Inventory<Item> inventory;

public void Run()
{
    var cachedInventory = Inventory<Item>.Instance;  //returns null
    var cachedEquipmentInventory = EquipmentInventory.Instance as EquipmentInventory;  //returns null
}

两个语句都返回 null。

这样做的目的是，每种库存类型将是一个单件，并且每种类型的库存将实现不同的物品类型，因此基础库存将使用 Item 类型，而 Equipment 库存将使用 Equipment 实现项目类型。

这是另一种方法，似乎可以解决这个问题

public abstract class Inventory<T, TClass> 
        : Singleton<TClass> where TClass 
        : MonoBehaviour where T : Item
    {

    }
public class EquipmentInventory : Inventory<Equipment, EquipmentInventory>
    {

    }

我还没有用实际代码完全测试过这个，但是当我更彻底地测试它时会更新

请帮忙。

Answer 1

主要问题是由

引起的

public class Inventory<T> : Singleton<Inventory<T>> : where T : Item { }

在这里，您将泛型类型Iventory<T>“传递”到Singleton，即使稍后您显式地从该Inventory<T> 类继承。

---

这是一种可能的解决方案，虽然起初看起来有点奇怪：

让您的 Inventory 采用第二种通用​​类型，根据需要在类中使用第一种类型，并将第二种类型“转发”到 Singleton<T>，例如

// Note how for the limitation via where you still can use the generic type
// which makes sure no other MonoBehaviour can be passed to TSelf by accident
public class Inventory<TItem, TSelf> : Singleton<TSelf> where TItem : Item where TSelf : Inventory<TItem,TSelf>
{
    public TItem reference;

    private void Awake()
    {
        if (!reference) reference = ScriptableObject.CreateInstance<TItem>();
    }
}

然后在实现中，您的通行证另外使用您自己的最终（非通用）类型，以便可以正确“转发”到Singleton<T>，例如

public class EquipmentInventory : Inventory<Equipment, EquipmentInventory> { }

请注意，无论如何，此类必须位于名为 EquipmentInventory.cs 的单独文件中，否则它将无法作为 Unity 中的组件。

---

这现在有效，因为现在您显式传入 EquipmentInventory 类型为 TSelf，然后将其转发到 Signleton<T>，因此 Instance 的返回类型显式为 EquipmentInventory。

---

通常习惯于为每个单独的类/类型拥有一个脚本文件。

此外，我会稍微更改您在 Item 和 Equipment 中的字段，例如

[CreateAssetMenu]
public class Item : ScriptableObject
{
    [SerializeField] private string _name;

    public string Name => _name;

    private void Awake()
    {
        _name = GetName();
    }

    protected virtual string GetName()
    {
       return nameof(Item);
    }
}

和

[CreateAssetMenu]
public class Equipment : Item
{
    protected override string GetName()
    {
        return nameof(Equipment);
    }
}

---

这就是它的样子，例如

public class Example : MonoBehaviour
{
    public EquipmentInventory equipmentInventory;

    [ContextMenu("Run")]
    public void Run()
    {
        equipmentInventory = EquipmentInventory.Instance;
    }
}