1

我有一个有趣的场景，我一直在考虑，想知道 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() internal 似乎可以在某种程度上解决这个问题，但我正在寻找其他解决方案。这里的想法是图形应该调用父类。这是设计的味道吗？有没有更好的方法来解决这个问题？

ACTUAL 类型未清理并张贴在这里。稍后我可能会清理它们。

4

3 回答 3

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.

如果您想限制外部参与者访问接口中的所有方法，这就引出了一个问题，即为什么要使用接口。

于 2013-06-02T00:31:20.050 回答
1

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

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 handler) 添加处理程序并使用 RunAllHandlers() 运行所有处理程序。

于 2013-06-02T00:34:17.020 回答
1

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

于 2013-06-02T01:00:10.770 回答