设计模式建议：图形 - >计算 [英] design pattern advice: graph -> computation

问题描述

我有一个域模型，保存在一个数据库中，代表一个图形。图形由通过分支连接的节点（例如NodeTypeA，NodeTypeB）组成。两个通用元素（节点和分支将具有属性）。一个图形将被发送到一个计算引擎。要执行计算，引擎必须如此初始化（简化的伪代码）：

  Engine Engine = new Engine（）; 
对象ID1 = Engine.AddNodeTypeA（TypeA.Property1，TypeA.Property2，...，TypeA.Propertyn）; 
对象ID2 = Engine.AddNodeTypeB（TypeB.Property1，TypeB.Property2，...，TypeB.Propertyn）; 
 Engine.AddBranch（ID1，ID2）; 
  

最后计算如下执行：

  Engine.DoSomeComputation（）; 
  

我只是想知道，如果有任何相关设计模式，那有助于实现上述使用良好的设计原则。我希望这是有道理的。任何反馈将非常感激。

解决方案

引擎看起来像打破/关闭的主体，也可能是单一责任主体。如果Engine的目的是做一些计算，那么它可能不应该知道如何从不同的节点类型创建ID1或ID2，这将是SRP违规。名称AddNodeTypeA和AddNodeTypeB导致我认为可能有一个C，D等。这意味着任何新的NodeType将要求Engine类更改哪个OCP似乎被破坏。

适配器模式将解决这两个问题

  class Engine 
 {
 public void AddBranch（Branch branch1，Branch branch2）
 {
 // do something 
} 
 
 public void DoSomeComputation（）; 
 {
 //做某事
} 
} 
 
接口BranchAdapter 
 {
分支GetBranch（）; 
} 
 
 class NodeTypeABranchAdapter：BranchAdapter 
 {
 private readonly TypeA _typeA; 
 public NodeTypeABranchCreator（TypeA typeA）
 {
 _typeA = typeA; 
} 
 
 public Branch GetBranch（）
 {
 //执行处理以取代_typeA并将其转换为Branch 
} 
} 
 
 class NodeTypeBBranchAdapter：BranchAdapter 
 {
 private readonly TypeB _typeB; 
 public NodeTypeABranchCreator（TypeB typeB）
 {
 _typeB = typeB; 
} 
 
 public Branch GetBranch（）
 {
 //处理取_typeB并将其转换为Branch 
} 
} 
  

调用代码可以这样工作

  var engine = new Engine（）; 
分支ID1 =新的NodeTypeABranchAdapter（TypeA）.GetBranch（）; 
分支ID2 =新的NodeTypeBBranchAdapter（TypeB）.GetBranch（）; 
 engine.AddBranch（id1，id2）; 
 engine.DoSomeComputation（）; 
  

I have a domain model, persisted in a database, which represents a graph. A graph consists of nodes (e.g. NodeTypeA, NodeTypeB) which are connected via branches. The two generic elements (nodes and branches will have properties). A graph will be sent to a computation engine. To perform computations the engine has to be initialised like so (simplified pseudo code):

Engine Engine = new Engine() ;
Object ID1 = Engine.AddNodeTypeA(TypeA.Property1, TypeA.Property2, …, TypeA.Propertyn);
Object ID2 = Engine.AddNodeTypeB(TypeB.Property1, TypeB.Property2, …, TypeB.Propertyn);
Engine.AddBranch(ID1,ID2);

Finally the computation is performed like this:

Engine.DoSomeComputation();

I am just wondering, if there are any relevant design patterns out there, which help to achieve the above using good design principles. I hope this makes sense. Any feedback would be very much appreciated.

解决方案

Engine looks like it's breaking the Open/Closed principal and probably the Single Responsibility principal too. If Engine's purpose is to do some computation then it probably shouldn't know how to create ID1 or ID2 from different node types which would be an SRP violation. The names AddNodeTypeA and AddNodeTypeB lead me to think that there could be a C, D, etc. This means that any new NodeType would require the Engine class to change which is where OCP appears to be broken.

The Adapter pattern would resolve both of those concerns

class Engine
{
    public void AddBranch(Branch branch1, Branch branch2)
    {
        //do something
    }

    public void DoSomeComputation();
    {
        //do something
    }
}

interface BranchAdapter
{
    Branch GetBranch();
}

class NodeTypeABranchAdapter : BranchAdapter
{
    private readonly TypeA _typeA;
    public NodeTypeABranchCreator(TypeA typeA)
    {
        _typeA = typeA;
    }

    public Branch GetBranch()
    {
        //do processing to take _typeA and transform it into Branch
    }
}

class NodeTypeBBranchAdapter : BranchAdapter
{
    private readonly TypeB _typeB;
    public NodeTypeABranchCreator(TypeB typeB)
    {
        _typeB = typeB;
    }

    public Branch GetBranch()
    {
        //do processing to take _typeB and transform it into Branch
    }
}

The calling code could then work like so

var engine = new Engine();
Branch id1 = new NodeTypeABranchAdapter(TypeA).GetBranch();
Branch id2 = new NodeTypeBBranchAdapter(TypeB).GetBranch();
engine.AddBranch(id1, id2);
engine.DoSomeComputation();

这篇关于设计模式建议：图形 - >计算的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！