避免调用基类的受保护成员

Question

这是一个树结构的愚蠢示例，其中每个节点都执行不同类型的操作，但恰好一个节点（任何节点）必须在项目开始和结束时执行一些共同的工作。

public abstract class Employee
{
    public void StartProject()
    {
        AnnounceProjectToNewspapers();
        DoActualWork();
        PutProductOnMarket();
    }

    protected abstract void DoActualWork();

    private void AnnounceProjectToNewspapers() { }
    private void PutProductOnMarket() { }
}

public class Engineer : Employee
{
    protected override void DoActualWork()
    {
        // Build things.
    }
}

public class Salesman : Employee
{
    protected override void DoActualWork()
    {
        // Design leaflets.
    }
}

public class Manager : Employee
{
    protected override void DoActualWork()
    {
        // Make gantt charts.

        // Also delegate.
        foreach (var subordinate in subordinates)
            // ...but then compiler stops you.
            subordinate.DoActualWork();
    }

    private List<Employee> subordinates;
}

问题是，您不能在基类上调用受保护的方法DoActualWork()。

我看到的两个解决方案是：

• 将DoActualWork() 公开。 但这将允许任何人在没有AnnounceProjectToNewspapers() 或PutProductOnmarket() 的情况下调用它。
• 将DoActualWork()设为内部。但这会阻止其他程序集使用“管理系统”。

是否有人们用来避免这种限制的标准变通方法？

Answer 1

考虑到所有的响应，我想到了一个折衷方案：通过内部方法使用间接调用。换句话说，非正式的cmets的一个穷人的朋友声明。

以下是相关位：

public abstract class Employee
{
    // Meant to be called by Manager class only.
    internal void FollowTheLeader()
    {
        DoActualWork();
    }
}

public class Manager : Employee
{
    protected override void DoActualWork()
    {
        // Make gantt charts.

        // Also delegate.
        foreach (var subordinate in subordinates)
            // ...but then compiler stops you.
            subordinate.FollowTheLeader();
    }
}

从其他程序集派生类将能够自定义员工和经理所做的工作，但他们无法让任何人在没有适当上下文的情况下工作。

程序集中的类可以做任何事情，但我们假设您可以相信开发框架的人会按照 cmets 中的说明进行操作。

Answer 2

我想出了一个这样的解决方案（这还没有经过测试）

public interface IEmployee {
    void StartProject();
    void DoWork();
}

public abstract class EmployeeBase : IEmployee {
    public void StartProject() {
        AnnounceProjectToNewspapers();
        DoActualWork();
        PutProductOnMarket();
    }

    void IEmployee.DoWork() {
        // Maybe set a flag to see whether the work has been already done by calling StartProject().
        this.DoActualWork();
    }

    protected abstract void DoActualWork();

    private void AnnounceProjectToNewspapers() { }
    private void PutProductOnMarket() { }
}

public class Employee : EmployeeBase {
    protected override void DoActualWork() {
        // Log system Action
    }
}

public class Engineer : Employee {
    protected override void DoActualWork() {
        // Build things.
    }
}

public class Salesman : Employee {
    protected override void DoActualWork() {
        // Design leaflets.
    }
}

public class Manager : Employee {
    protected override void DoActualWork() {
        DoWorkInternal();
    }

    private void DoWorkInternal() {
        foreach (var subordinate in subordinates)
            subordinate.DoWork();
    }

    private List<IEmployee> subordinates;
}

Answer 3

我有几种方法可以满足您的需求。

1. 第一个也是显而易见的方法是从经理而不是员工继承工程师和销售员。但这让继承听起来很荒谬。每个工程师都是经理（我希望这是真的。）

2. 正如你所提到的，

公开 DoActualWork()

这确实有效。然后，为了防止任何其他方法调用 DoActualWork()，您可以使用反射/堆栈跟踪找出类的类型并阻止无效类型。参考here

但这两种方法对我来说都感觉很吵。绝对应该有一种方法来设计类以满足您的需求。