我有一个班级Item
:
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;
}
}
我的课程Equip
源自Item
:
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);
Item
base的构造函数将使用CachedReference
的{{1}}属性,而不是Item
的新CachedReference
属性。如果我初始化Equip
类型的对象,我怎么能这样做,基类Equip
类将使用Item
的{{1}}值,而不是CachedReference
?
答案 0 :(得分:0)
通常,自动的理想方式是CachedReference
为virtual
方法(或:间接调用 virtual
方法),Equip
覆盖。
然而!在这种情况下,您正在谈论构造函数;你应该不在构造函数中调用virtual
方法。相反,另一种方法是通过构造函数传递所需的值 down (为此目的,它可能是一个不同的protected
构造函数。)
例如:
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;
}
private static GetCachedReference(int id)
=> Server.Instance.Data.Equips[this.ID];
public Item CachedReference => GetCachedReference(ID);
public new Equip CachedReference => GetCachedReference(ID);
public Equip(int id) : base(id, GetCachedReference(id).Value) { }
答案 1 :(得分:0)
一般来说,我会说这是一个糟糕的设计。你的类(Item)一次处理2件事(存储值和缓存)。比如说稍后你想要改变缓存机制(到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];
}
}