Question

我有一个有趣的场景，我一直在考虑，想知道SO可能有什么解决方案，以获得比我想出的更优雅的解决方案。

考虑以下类型

public class Session : ISessionGraphTransitionHandler
{
   public void Handler1()
   {
      // do stuff that leverages this object instance
   }

   public void Handler2()
   {
      // do stuff that leverages this object instance
   }
   // ...

   public void HandlerN()
   {
      // do stuff that leverages this object instance
   }

   private Graph sessionGraph;

   public Session()
   {
      sessionGraph = new Graph(this); // where ISessionGraphTransitionHandler is expected
   }
}

目前界面看起来像这样：

public interface ISessionGraphTransitionHandler
{
   public void Handler1();
   public void Handler2();
   ...
   public void HandlerN();
}

所有这一切的问题是，外部参与者可以调用sessionInstance.Handler1()内部似乎可以在某种程度上解决这个问题，但我正在寻找其他解决方案。这里的想法是图应该调用父类。这是一种设计气味吗？有没有更好的方法来解决这个问题？

ACTUAL类型未清理并发布here。我可能会稍后清理它们。

Answer 1

如果不了解您正在尝试解决的问题以及对可能解决方案的限制，则很难回答。但是，听起来您可能需要使用子类和受保护的成员。因此，例如，您可以将Handler1()...HandlerN()保留在接口之外，而是将其声明为父类中的受保护，如果您想在子类中强制实现，也可以将其声明为抽象。

public class ParentClass
{
    protected abstract void Handler1();
    ...
    protected abstract void HandlerN();
}

public class Session : ParentClass, ISessionGraphTransitionHandler
{
    private void Handler1();
    ...
    private void HandlerN();

}

外部参与者无法访问的任何内容都可以是ParentClass的抽象成员。公开的任何人都可以是ISessionGraphTransitionHandler的成员。

如果你想限制，那么就要问你为什么要使用界面了外部参与者访问界面中所有方法。

Answer 2

我不确定我的问题是否正确，所以我猜一点。

public interface IHandler
{
    void Handle();
}

public class HandlerDirector
{
    IList<IHandler> Handlers = new List<IHandler>();

    public void AddHandler(IHandler handler)
    {
        Handlers.Add(handler);
    }

    public void RunAllHandlers()
    {
        foreach (IHandler handler in Handlers)
            handler.Handle();
    }
}

现在，外部代码使用AddHandler（IHandler处理程序）添加处理程序，并使用RunAllHandlers（）运行所有处理程序。

Answer 3

这里一个合理的解决方案是利用C＃中的显式接口实现机制，只允许通过IEncounterTransitionHandler接口访问接口元素，将接口标记为内部，并假设开发人员不会在内部滥用此类型。

管理接口实现成员的可访问性

3 个答案: