重写嵌套类函数或使用委托？**

Question

我有一个基类，里面有一个嵌套类型。外部（基）类型中有一个函数，稍后会被它的子类型覆盖。事实上，从OO的角度来看，这个函数属于内部类型，但我仍然需要它，被的子类型覆盖基类。

我应该使用此函数作为来自内部类型的回调，还是将其移至内部类型内部，然后使用子类型 code> 从那里覆盖它？

编辑：添加示例代码

class A
{
    protected void func() { /* do something */ }
    class B { /**/ }
}

// OR

class A
{
    class B
    {
        protected void func() { /* do something */ }
    }
}

// Then

class C : A
{
    override func() { /**/ }
}

Answer 1

我的建议是为内部类型函数创建一个委托，该委托由基类的构造函数启动：

internal class BaseClass
{
    public BaseClass(Action myAction)
    {
        this.innerType = new InnerType(myAction);
    }

    public BaseClass()
    {
        // When no function delegate is supplied, InnerType should default to
        // using its own implementation of the specific function
        this.innerType = new InnerType();
    }
}

如您所见，派生类型可以使用 < code>:base (overridenAction) 他们可以在最里面的类型中提供自己的函数实现。当然，您没有义务使用 Action，而是使用您想要的任何委托。

Answer 2

IMO你所描述的看起来像策略设计模式。考虑使用这种模式。您的代码将更易于维护，因为它包含易于识别的模式。你也可以看看状态设计模式，通常你必须在这两者之间进行选择，它们是紧密相连的连接。

Answer 3

在这种情况下：

class A
{
    class B
    {
        protected void func() { // do something }
    }
}

您无法从类 A 派生并重写类 B 中的 func()。

从您的描述来看，A 派生类应该能够覆盖内部类 B 中的某些函数（或功能），这表明您可能应该重新考虑您的设计。要么提取 B 并且不将其设为内部类，要么将您想要的功能通过这样的接口覆盖显式依赖项：

class A
{
    private B _MyB;
    public A(ISomeBehaviour behaviour)
    {
        _MyB = new B(behaviour);
    }
}

无论如何，如果您想坚持自己的设计，那么我不会推荐使用委托方法，而不是选择覆盖，因为使用委托，如果您在子类中需要添加装饰，那么添加装饰会变得更加困难。

Answer 4

这就是外部类如何充当内部服务类的策略。

请注意，不建议使用诸如 TemplateMethod 和 Strategy 之类的模式名称作为真实的类名称，请使用在域中有意义的任何名称。同样适用于Outer 和Inner。

public class Consumer
{
    public void Foo()
    {
        IOuterFoo fooService = new Derived();
        fooService.OuterFoo();
    }
}

// ...

public interface IOuterFoo
{
    void OuterFoo();
}

abstract class Base : Base.IStrategy, IOuterFoo
{
    public void OuterFoo() { _service.Foo(); }

    private readonly InnerService _service;

    protected Base() { _service = new InnerService(this); }

    private interface IStrategy { void Foo(); }

    private class InnerService
    {
        private readonly IStrategy _strategy;
        public InnerService(IStrategy strategy) { _strategy = strategy; }
        public void Foo() { _strategy.Foo(); }
    }

    void IStrategy.Foo() { TemplateMethodFoo(); }

    protected abstract void TemplateMethodFoo();
}

class Derived : Base
{
    protected override void TemplateMethodFoo()
    {
        throw new NotImplementedException();
    }
}