不能转换作为派生类的继承类字段

Question

在我解释我的问题之前，请记住，我选择了这样的架构，因为这将在 Unity 下的库存系统中使用，所以我必须将 Item 分开，这是一个 MonoBehavior，它只是来自其数据的世界上的某些东西，这些只是用于库存目的的值......如果这有意义的话。

我的架构是这样的：

public class ItemData
{
    // some fields...
    public string _name; //should be private with its properties but it doesn't matter in the current example
}

public class EquipmentData : ItemData
{
    // some additional fields...
    public float _weight;
}

public class Item
{
    private ItemData _data;

    //Properties
    public virtual ItemData Data { get; set; }
}

public class Equipment : Item
{
    //Properties
    public override ItemData Data 
    {
        get { return _data as EquipmentData; }
        set { _data = value as EquipmentData; }
    }
}

所以，基本上我有一个更深的项目层次结构，但 1 级足以解释我自己。 （它一直像武器：装备一样）......

问题是，如果我将private ItemData _data; 留在Item 类中，并在Equipment 类中添加private EquipmentData _eData;，我将拥有ItemData 字段两次，因为EquipmentData 继承ItemData 等等对于其他派生类...如果我有一个派生自 Equipment 等的类，请第三次获得它...

类似：

public class Item
{
    private ItemData _data;
}

public class Equipment : item
{
    private EquipmentData _eData;
}

ItemData 的字段如_name 将在Equipment 中出现两次，我不希望这样...

所以我猜我的架构有问题，并且可能有一种方法可以绕过这种看起来有点“脏”的方法，但我在网上找不到任何特定于这个问题的东西，我已经达到了我的极限.

我尝试过的：

• 我曾尝试在Equipment 中使用关键字new，我认为我可以隐藏Item 类中的初始protected ItemData _data;，然后在protected new EquipmentData _data; 中添加protected new EquipmentData _data;，但它显然不会让我，因为对于 Shadow _data 它需要是相同的类型，似乎不适用于派生类型。
• 另外，如我的代码示例所示，我已尝试覆盖该属性以根据调用它的类返回正确的类型，强制转换始终返回 null...

我仍然觉得奇怪的是，我最终尝试实现类似的东西，所以我乐于接受以更好的方式重组事物的新想法，或者如果有人有我没想过的解决方案来保留那些方式，但让他们工作，这将是非常好的。

我希望我的问题足够详细，如果没有，我可以在需要时解决问题。

Answer 1

您需要的是Generic Classes。这样，您可以为每个Item 分配其正确的ItemData 类型。所以Equipment 将分配其EquipmentData。

//TItemData is a name of this generic type. 
//It could be T for example, just like variable name. 
//These type names start from T by convention. 
//This is not a new class or something like that.
//where TItemData : ItemData is a constraint, 
//that assumes that this type should be a subtype of ItemData
public abstract class Item<TItemData> where TItemData : ItemData
{
    protected TItemData Data;
}

//EquipmentData is a subtype of ItemData, so it fits here. 
//No chances to write, for example, IntEquipment : Item<int> , 
//because int does not derive from ItemData.
public class Equipment : Item<EquipmentData>
{
    //here Data will be of EquipmentData type, without any casting.
}

通过实现上述你将实现Type Safety。

编辑

要创建一个正确扩展Equipment（我们称其为Weapon）并拥有其正确ItemData（我们称其为WeaponData）的类，您需要编写如下内容：

编辑Equipment，使其成为abstract：

public abstract class Equipment<TEquipmentData> 
: Item<TEquipmentData> 
//this constraint is VERY important, as EquipmentData derives from ItemData, thus fulfill Item<TItemData> constraint.
where TEquipmentData : EquipmentData
{
    //Data will have EquipmentData type here.
}

创建WeaponData

public WeaponData : EquipmentData
{
}

创建Weapon

public class Weapon : Equipment<WeaponData>
{
   //Data will have WeaponData type here.
}

Answer 2

这行得通：

public class OverridePropertiesWithSameField
{
    public void Test()
    {
        ChildItem ci = new ChildItem();
        ChildItemData cid = new ChildItemData();
        cid.ItemDataProp = "ItemDataProperty"; // Inherited
        cid.ChildItemDataProp = "ChildItemDataProp"; // Specific
        ci.ItemData = cid;

        // You know you need ChildItemData type here.
        var childItemData = ci.ItemData as ChildItemData;
        string itemDataProp = childItemData.ItemDataProp;
        string childItemDataProp = childItemData.ChildItemDataProp;
    }
}

public class Item
{
    protected ItemData data;
    public virtual ItemData ItemData { get; set; }
}

public class ChildItem : Item
{
    public override ItemData ItemData
    {
        get { return base.data; }
        set { base.data = value; }
    }
}

public class ItemData
{
    public string ItemDataProp { get; set; }
}

public class ChildItemData : ItemData
{
    public string ChildItemDataProp { get; set; }
}

Answer 3

您可以使用带有泛型类型约束（where）的泛型类型参数。

public class Item<DATA> where DATA : ItemData
{
    public virtual DATA Data { get; set; }
}

现在您的班级可以使用特定的 ItemData：

Item<ItemData> has property 
public virtual ItemData Data { get; set; }

Item<EquipmentData> has property
public virtual EquipmentData Data { get; set; }

Item<ANOTHER> has property
public virtual ANOTHER Data { get; set; }