C# 继承的成员新属性

我有一个类

项目

：

   public class Item
    {
        public int ID { get; private set; }
        public int Value { get; private set; }

        public Item CachedReference
        {
            get
            {
                return Server.Instance.Data.Items[this.ID];
            }
        }

        public Item(int id)
        {
            this.ID = id;
            this.Value = this.CachedReference.Value;
        }
}

public sealed class Equip : Item
{
    public new Equip CachedReference
    {
        get
        {
            return Server.Instance.Data.Equips[this.ID];
        }
    }
}

public Equip(int id) : base(id) { }

我有一个类

装备

，它来自

物品

：

   public class Item
    {
        public int ID { get; private set; }
        public int Value { get; private set; }

        public Item CachedReference
        {
            get
            {
                return Server.Instance.Data.Items[this.ID];
            }
        }

        public Item(int id)
        {
            this.ID = id;
            this.Value = this.CachedReference.Value;
        }
}

public sealed class Equip : Item
{
    public new Equip CachedReference
    {
        get
        {
            return Server.Instance.Data.Equips[this.ID];
        }
    }
}

public Equip(int id) : base(id) { }

当我打电话时：

Equip equip = new Equip(id);

项

基的构造函数将使用

项

的

缓存引用

属性，而不是

装备

的新

缓存引用

属性。如果初始化类型为

equipment

的对象，基本

Item

类将使用

equipm

的

CachedReference

值，而不是

Item

？

通常，自动执行该操作的理想方法是将

CachedReference

作为

虚拟
方法（或：间接调用
虚拟
方法），
装备
覆盖

但是！在本例中，您指的是构造函数；在构造函数期间不应调用
虚
方法。相反，另一种方法是通过构造函数向下传递所需的值（为此，它可能是另一个
受保护的
构造函数）

例如：

private static GetCachedReference(int id)
   => Server.Instance.Data.Items[id];
public Item(int id) : (id, GetCachedReference(id).Value) {}
protected Item(int id, int value)
{
    this.ID = id;
    this.Value = value;
}


通常，自动执行该操作的理想方法是将
CachedReference
作为
virtual
方法（或：间接调用
virtual
方法），该方法将
装备
覆盖

但是！在本例中，您指的是构造函数；在构造函数期间不应调用
虚
方法。相反，另一种方法是通过构造函数向下传递所需的值（为此，它可能是另一个
受保护的
构造函数）

例如：

private static GetCachedReference(int id)
   => Server.Instance.Data.Items[id];
public Item(int id) : (id, GetCachedReference(id).Value) {}
protected Item(int id, int value)
{
    this.ID = id;
    this.Value = value;
}


一般来说，我会说这是一个糟糕的设计。你的类（项）同时处理两件事（存储值和缓存）。比如说，以后你想更改缓存机制（到Redis或其他），这将非常困难

底线是您应该有一个单独的类/接口来处理缓存

这是一个（非常）简化的版本

public class Item
{
    public int Id { get; }

    public Item(int id)
    {
        Id = id;
    }
}

public class Equip : Item
{
    public Equip(int id) : base(id)
    {
    }
}

public class CacheManager
{
    public TItem GetItem<TItem>(int id) where TItem : Item
    {
        if (typeof(TItem) == typeof(Equip))
        {
            return Server.Instance.Data.Equips[id];
        }

        return Server.Instance.Data.Items[id];
    }
}

公共类项目
{
公共int Id{get；}
公共项目（int id）
{
Id=Id；
}
}
公共类装备：物品
{
公共装备（内部id）：基地（id）
{
}
}
公共类缓存管理器
{
公共TItem GetItem（int-id），其中TItem:Item
{
如果（类型（滴度）=类型（装备））
{
返回Server.Instance.Data.Equips[id]；
}
返回Server.Instance.Data.Items[id]；
}
}
一般来说，我会说这是一个糟糕的设计。您的类（项）同时处理两件事情（存储值和缓存）。例如，稍后您要更改缓存机制（到Redis或其他），这将非常困难

底线是您应该有一个单独的类/接口来处理缓存

这是一个（非常）简化的版本

public class Item
{
    public int Id { get; }

    public Item(int id)
    {
        Id = id;
    }
}

public class Equip : Item
{
    public Equip(int id) : base(id)
    {
    }
}

public class CacheManager
{
    public TItem GetItem<TItem>(int id) where TItem : Item
    {
        if (typeof(TItem) == typeof(Equip))
        {
            return Server.Instance.Data.Equips[id];
        }

        return Server.Instance.Data.Items[id];
    }
}

公共类项目
{
公共int Id{get；}
公共项目（int id）
{
Id=Id；
}
}
公共类装备：物品
{
公共装备（内部id）：基地（id）
{
}
}
公共类缓存管理器
{
公共TItem GetItem（int-id），其中TItem:Item
{
如果（类型（滴度）=类型（装备））
{
返回Server.Instance.Data.Equips[id]；
}
返回Server.Instance.Data.Items[id]；
}
}
在
equipment
中创建一个新的构造函数，该构造函数调用一个新的、无参数的基本构造函数，而该构造函数不执行任何操作，或者使用
virtual
和
override
而不是
new
。您尝试了什么？@CodeCaster问题是，因为
equipment
派生自
项
，所以它还需要
 Value
属性。因此，我确实希望基类获取基本值。@CodeCaster我确实使用了虚拟方法，并用
equipment
重写了它，但我希望
CachedReference
返回
equipment
类型，而不是
Item
，这样我就不必在构造函数中强制转换它。泛型可以作为一个选项吗？By在
equipment
中创建一个新的构造函数，该构造函数调用一个新的、无参数的基本构造函数，该构造函数不执行任何操作，或者使用
virtual
和
override
而不是
new
。您尝试了什么？@CodeCaster问题是，因为
equipment
派生自
项
，所以它还需要
值
property。因此我确实希望基类获取基本值。@CodeCaster我确实使用了虚拟方法并用
Equipment
重写了它，但是我希望
CachedReference
返回
Equipment
类型而不是
项，这样我就不必在构造函数中强制转换它。泛型可以作为一个选项吗？您能我怎么能举个例子？我不太明白。@GilbertWilliams添加了一个例子，但有大约6种不同的方式来安排，包括存储引用本身，而不是值，以及在getter中执行.value。你能给我举个例子吗？我不太明白。@GilbertWilliams添加了一个例子，但有大约6种不同的方式布局方法，包括存储引用本身，而不是值，以及在getter中执行.value