2

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

使用的语言 - C#。

PS：我正在考虑使用InternalVisibleTo但意识到这会在装配级别应用

4

7 回答 7

4

我不明白这与“设计模式”有什么关系——这只是语言特性的问题。C# 没有一种语言特性可以轻松实现这种选择封装。

我猜你的选择是在层次结构中插入一个新类BaseWithExtras，派生自Base，并让一些孩子派生自Base和其他人BaseWithExtras，或者停止担心它，只是让所有派生类都可以使用该方法。

于 2011-07-11T17:22:28.633 回答
4

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

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

问问自己这个问题：有什么不同之Child2处？Child3他们自己有共同的行为，但对所有其他孩子有不同的行为？SpecialChild模型的行为和您在问题中给出的示例将是实施的地方AVeryPrivilegedMethod。

于 2011-07-11T17:24:23.127 回答
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
于 2011-07-11T17:23:19.747 回答
0

如果您只能访问基类，我会说在基方法中对类的类型使用反射，并且只允许您想要正确使用基方法的类。如果不是这种情况，并且您有能力修改层次结构或派生类，只需创建另一个从您的基类派生的类，该类公开您感兴趣的方法，并让您的类从中派生。

于 2011-07-11T17:26:37.297 回答
0

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

 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），并且由于某种原因需要您声明的层次结构。还有其他答案表明新级别的子类，这可能是您情况下的最佳答案。如果没有，这可能会有所帮助。

于 2011-07-11T17:26:59.257 回答
0

与 Dependency Injection 的良好旧关联如何（因此您可以稍后在需要时更改它以允许其他类访问这些函数）。

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，您可以注入AllowPrivilegesorNoPrivileges版本。

// 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
于 2011-07-11T17:29:10.687 回答
0

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

于 2011-12-13T13:22:16.010 回答