Wie kann man den Algorithmus steuern/koordinieren

Question

Das folgende Bild ist ein einfacher Teil eines komplexen Algorithmus. Ich versuche, einige Klassen in Übereinstimmung mit Algorithmus vorzubereiten.

abstract class Person 
{ 
    public string HasXRecords { get; set; } 
    public int PersonAnotherFeature { get; set; } 
    public List<X> Xs { get; set; } = new List<X>(); 
} 
abstract class X 
{ 
    //There will more than 1000 type subX classes 
} 

interface IAdder 
{ 
    void AddXToList(); 
} 

interface IRemover 
{ 
    void RemoveXFromList(); 
} 

class XAdderFactory 
{ 
    private Person _person; 
    public bool PersonHasNoRecords 
    { 
     get 
     { 
      return string.IsNullOrEmpty(_person.HasXRecords); 
     } 
    } 
    public XAdderFactory(Person person) 
    { 
     this._person = person; 
     if (PersonHasNoRecords) 
     { 
      new XListMakerAFactory(person); 
     } 
     else 
     { 
      new XListMakerB(person); 
     } 
    } 
} 

class XListMakerB: IAdder 
{ 
    private Person _person; 
    public XListMakerB(Person person) 
    { 
     this._person = person; 
     AddXToList(); 
     new PersonXListEvaluator(person); 
    } 
    public void AddXToList() 
    { 
     //Dynamic instance of X will be added in to person Xlist. 
    } 
} 

class XListMakerAFactory 
{ 
    public XListMakerAFactory(Person person) 
    { 
     switch (person.PersonAnotherFeature) 
     { 
      case 1:new XListMakerA1(person); 
       break; 
       //there will be XListMakerA2,XListMakerA3 etc. 
     } 
     new XRemoverFactory(person); 
    } 
} 
class XListMakerA1: IAdder 
{ 
    private Person _person; 
    public XListMakerA1(Person person) 
    { 
     this._person = person; 
     AddXToList(); 
     new PersonXListEvaluator(person); 
    } 
    public void AddXToList() 
    { 
     //_person.Xs.Add(new X1()); 
     // According to business logic,X2,X3 etc. will be added manually. 
    } 
} 

class XRemoverFactory 
{ 
    public XRemoverFactory(Person person) 
    { 
     new XRemoverFromList1(person); 
     new XRemoverFromList2(person); 
    } 
} 

class XRemoverFromList1 : IRemover 
{ 
    private Person _person; 
    public XRemoverFromList1(Person person) 
    { 
     this._person = person; 
     RemoveXFromList(); 
    } 
    public void RemoveXFromList() 
    { 
     //According some business logic some Xs will be removed. 
    } 
} 

class XRemoverFromList2 : IRemover 
{ 
    private Person _person; 
    public XRemoverFromList2(Person person) 
    { 
     this._person = person; 
     RemoveXFromList(); 
    } 
    public void RemoveXFromList() 
    { 
     //According some business logic some Xs will be removed. 
    } 
} 
class PersonXListEvaluator 
{ 
    public PersonXListEvaluator(Person person) 
    { 
     //According to business rules evaluation will be cordinated. 
    } 
} 

Mein Hauptanliegen ist es, eine Menge jeweiligen Kategorie zu schaffen, succes algorithm.I versuchen, dieses Niveau Factory-Methoden entwerfen wird, welche Klasse (auf derselben Ebene) entscheiden muss auf dieser Ebene Nachdem das nächste Level Fabrik instanziiert werden Methode instanziiert.Flow wird im Konstruktor der level factory-Methoden verwaltet.Haben Sie das für überschaubar, maintable? Bieten Sie eine bessere Lösung?

Answer 1

Erzeugungsmuster:

Sie müssen als Abstract_factory, die nach Ihren Wünschen zwei Arten von Fabriken gibt -type_list_a und type_list_b.

Verhaltensmuster:

Wenn Sie für den Austausch von Algorithmus zur Laufzeit dynamisch suchen, dann sollten Sie Strategy_pattern mit Context verwenden.

Kontext kennt und gibt einen bestimmten Algorithmus zurück, so dass der Client nicht alle 100 oder 1000 Klassen kennt, die einen Algorithmus implementieren.

Real World Example of the Strategy Pattern bietet ein gutes Beispiel.

Strukturmuster:

Wenn Sie die Komplexität für den Kunden zu verstecken, ohne alle Subsysteme auszusetzen, verwenden Facade Muster.

Sehen Sie sich sourcemaking Tutorials für weitere Details zu Anwendungsfällen jedes Musters an.