Question

如果我有代码：

List<Type> Requires = new List<Type>();

如何限制此列表中的类型，以便它们具有共同的父级？

例如：

List<Type : Component> Requires = new List<Type>()

编辑：更多背景，所以也许人们可以理解为什么我需要这个。我有一个班级Entity，其中包含Components列表。每个组件都需要有Component类型的列表，这些类型充当依赖项列表。因此，在运行时，当您尝试将Component添加到Entity时，它会快速检查Entity是否已将所需组件附加到其上。

示例：

//Entity.cs
//...
_components = new List<Component>();
//...
public T AddComponent<T>() where T : Component, new()
{
    var temp = new T();
    if (_components.Exists((x) => x is T)) return null;
    foreach (var t in temp.Requires)
    {
        if (_components.Exists(x => x.GetType() == t)) return null;
    }
    _components.Add(new T());
    temp.gameObject = this;
    return temp;
}
//...

//Component.cs
//...
protected internal Entity gameObject;
protected internal List<Type> Requires { get; }
//...

Answer 1

经过大量工作，我找到了解决自己问题的方法。

//Component.cs
public abstract class Component {
    //...
    protected internal Entity gameObject;
    private RequiresList _requires;
    //...
    protected internal RequiresList Requires
    {
        get => _requires;
        private set => _requires = (RequiresList)value.FindAll(x => x.IsSubclassOf(typeof(Component)));
    }
    //...
    public class RequiresList : List<Type>
    {
        public RequiresList() { }
        public RequiresList(IEnumerable<Type> types) : base(types) { }
        public RequiresList(int capacity) : base(capacity) { }

        public new Type this[int index]
        {
            get => base[index];
            set
            {
                if (isComp(value))
                    base[index] = value;
            }
        }

        public new void Add(Type type)
        {
            if (isComp(type))
                base.Add(type);
        }

        private static bool isComp(Type type)
        {
            return type.IsSubclassOf(typeof(Component));
        }
    }
    //...
}

//Entity.cs
public abstract class Entity {
    //...
    _components = new List<Component>();
    //...
    public T AddComponent<T>() where T : Component, new()
    {
        var temp = new T();
        if (_components.Exists((x) => x is T)) return null;
        foreach (var t in temp.Requires)
        {
            if (_components.Exists(x => x.GetType() == t)) return null;
        }
        _components.Add(new T());
        temp.gameObject = this;
        return temp;
    }
    //...
}

我创建了一个新的存储类型调用RequiresList，它会检查插入其中的所有System.Type，看看它们是否是Component的子类。我还确保如果有人试图用全新的列表替换列表，它将删除新列表中不是Component的

的任何索引。

将System.Type的列表约束为从基类型继承的类型

1 个答案: