当我只希望某些派生类能够访问基类中的方法时，应使用什么设计模式？

Question

我这里有一个独特的问题/情况。尝试使其尽可能简单。我有一个基类（比如 Parent）和一大堆直接从基类（Parent）派生的派生类（比如 Child1、Child2 ..ChildN）。我想更改基类并添加一个“AVeryPrivilegedMethod”，该方法只能由 Child2 和 Child3 访问，而不能由任何其他 Children 访问（或者使其可配置，以便将来 Child5 也可以在将来使用它，只需进行最小的更改）。什么设计模式/架构模式适合这个要求？

使用的语言 - C#。

PS：我正在考虑使用 InternalVisibleTo 但是意识到这在汇编级别得到应用

Answer 1

听起来好像您缺少另一个抽象类（SpecialChild，因为需要一个更好的名称），它继承自Parent，但是>Child2 和 Child3 是派生的。

                    Parent
                      | 
   |------------------|------------|----------|
Child1            SpecialChild   Child4    Child5
                      |
         |---------------------|
      Child2                 Child3

问自己这个问题：Child2 和 Child3 有什么不同，以至于它们本身具有共同的行为，但与所有其他子级有不同的行为？ SpecialChild 对该行为进行建模，在您的问题中给出的示例中，将是实现 AVeryPrivilegedMethod 的地方。

Answer 2

我不明白这与“设计模式”有什么关系——这只是语言特性的问题。 C# 不具备允许这种轻松选择封装的语言功能。

我猜你的选择是在层次结构中插入一个新类，BaseWithExtras，派生自Base，并让一些子类派生自Base，并且其他来自 BaseWithExtras，或者不再担心它，只需使该方法可用于所有派生类。

Answer 3

您可能想要进行另一个抽象级别：

public class Parent { }
public class MethodContainer : Parent { public void SomeMethod() { } }

然后每个子类都会继承适当的类：

// Does not have method
public class ChildA : Parent

// Has Method
public class ChildB: MethodContainer

Answer 4

如果您只能访问基类，我会说在基方法中对类的类型使用反射，并且只允许您想要正确使用基方法的类。如果情况并非如此，并且您有能力修改层次结构或派生类，只需从您的基派生另一个类来公开您感兴趣的方法，然后使您的类从中派生即可。

Answer 5

可能没有好的选择，因为这不是标准的保护级别。这是一个选项

 class Parent
 {
       private void AVeryPrivilegedMethod() {}
       public static void AVeryPrivilegedMethod(Child2 c) { ((Parent)c).AVeryPrivilegedMethod(); }
       public static void AVeryPrivilegedMethod(Child3 c) { ((Parent)c).AVeryPrivilegedMethod(); }
 }

稍后，您可以这样称呼它：

 Child2 c = new Child2();
 Parent.AVeryPrivilegedMethod(c);

这是假设您想要编译器检查（不在运行时使用反射来检查 Child2 和 Child3），并且出于某种原因需要您所说的层次结构。还有其他答案建议子类的新级别，这可能是您情况下的最佳答案。如果没有，这可能会有所帮助。

Answer 6

与依赖注入的良好旧关联怎么样（这样您可以在以后需要时更改它以允许其他类访问这些函数）。

public class Parent {
   private PrivilegedFunctions p;
   public Parent(PrivilegedFunctions inP) { p = inP; }
}

public interface PrivilegedFunctions {
   void SomeFuncHere();
}

public class AllowPrivileges : PrivilegedFunctions {
   public void AllowPrivileges () { }

   public void SomeFuncHere()
   { 
      // Actual implementation
   }
}

public class NoPrivileges : PrivilegedFunctions {
   public void NoPrivileges () { }

   public void SomeFuncHere()
   { 
      // No implementation
   }
}

public class Child1 : Parent {
   public Child1(PrivilegedFunctions inP) : base(inP) { }
}

然后，根据 Child，您可以注入 AllowPrivileges 或 NoPrivileges 版本。

// Child with privileges
Child1 with_priv = new Child1(new AllowPrivileges());
with_priv.SomeFuncHere(); // Does privileged operation
// Child without privileges
Child1 without_priv = new Child1(new NoPrivileges());
without_priv.SomeFuncHere(); // Does nothing

Answer 7

如果这些方法仅在某些子类中使用，那么将它们包含在继承层次结构中看起来不是一个好主意。这里我们想要实现的是实现重用，因此通过依赖注入进行组合将是一个好主意，但是如果您需要将该方法公开为类接口的一部分，那么 Mixin（如果在 C# 中可以的话）将是最好的选择去争取。