在子类中强制属性分配

Question

我有一个抽象的不可变基类，它定义了强制初始化子类，因此抽象调用而不是接口：

public abstract BaseLookup<TPoint, TItem>
{
    protected IEnumerable<TItem> items = null;

    protected BaseLookup(IEnumerable<TItem> items)
    {
        this.items = items;
        this.Initialize();
    }

    public abstract void Initialize();

    // problem deciding which one

    // either implementing a method...
    public abstract TItem GetItem(TPoint point);

    // ...or assigning a method
    public Func<TPoint, TItem> GetItem { get; protected set; }
}

GetItem 执行必须尽可能快。在初始化阶段，我必须检查初始项目并决定GetItem 方法应该做什么。它可以是基于这组项目的众多实现之一。

由于GetItem 方法必须尽可能快，因此将其定义为属性并为其分配一个直接的无分支 lambda 表达式似乎要好得多。但是使用上述定义的子类不会强制为其设置任何值，因此实现者可能会创建一个无效的子类。在属性上定义abstract 访问器将强制他们实现在语义上与实现方法相同的属性。这不会强制执行属性分配。

但是，如果我将其实现为重写的抽象方法，则特定方法将需要包含所有基于项目分支的分支。这意味着每次我调用该方法时都会评估这些分支，从而使其变慢（呃）。

我真正在寻找的是一种强制子类实现者设置GetItem 属性的方法。

我该怎么做？

还要考虑到这个类将被初始化一次，然后被多次使用。用于调用GetItem 方法。

一个简化的示例类（使用属性）

public class IteratorLookup<TPoint, TItem> : BaseLookup<TPoint, TItem>
{
    private TItem single = null;

    public IteratorLookup(IEnumerable<TItem> items) : base(items);

    public override void Initialize()
    {
        if (this.items != null && this.items.Count > 0)
        {
            if (this.items.Count > 1)
            {
                this.GetItem = point => this.items[this.GetIndex(point)];
            }
            else
            {
                this.GetItem = irrelevant => this.single;
            }
        }
        else
        {
            this.GetItem = irrelevant => null;
        }
    }

    private int GetIndex(TPoint point) { ... }
}

简化的示例类（使用方法）

public class IteratorLookup<TPoint, TItem> : BaseLookup<TPoint, TItem>
{
    private TItem single = null;

    public IteratorLookup(IEnumerable<TItem> items) : base(items);

    public override void Initialize()
    {
        // implementing minor speed up
        if (this.items != null && this.items.Count == 1)
        {
            this.single = items[0];
        }
    }

    public override TItem GetItem(TPoint point)
    {
        if (this.items != null && this.items.Count > 0)
        {
            if (this.items.Count > 1)
            {
                return this.items[this.GetIndex(point)];
            }
            return this.single;
        }
        return null;
    }

    private int GetIndex(TPoint point) { ... }
}

Answer 1

由于 GetItem 方法必须尽可能快，因此将其定义为属性并为其分配一个直接的无分支 lambda 表达式似乎要好得多

是什么让您认为它比方法更快？抽象方法是要走的路。这是一种更自然的方法，并且不存在属性可能未初始化的问题。

但是，如果我将其实现为重写的抽象方法，则特定方法将需要包含所有基于项目分支的分支。这意味着每次我调用该方法时都会评估这些分支，从而使其变慢（呃）。

不确定您的意思...是什么阻止您在GetItem 方法中放入与在GetItem 属性中放入Func<TPoint, TItem> 的代码相同的代码？

附带说明一下，在构造函数中调用虚方法 (Initialize) 时，您可能应该三思而后行，这可能会导致意想不到的问题：基构造函数在派生构造函数之前执行，但它始终是最派生的将被调用的Initialize 的实现；所以如果Initialize的派生实现依赖于派生类构造函数中初始化的东西，它将失败，因为它们还没有被初始化。

Answer 2

您需要为您的问题注入一些方面。属性非常简单，您无法确保子类是否已调用它。

您利用GetItem 方法将其从abstract 变为virtual，您的基类实现将抛出exception。

public virtual TItem GetItem(TPoint point)
{
    throw new Exception("Please implement GetItem method");
}

现在，任何没有覆盖该方法的子类都将陷入异常，并确保子类实现GetItem方法。