Comment peut être contrôlé/algorithme coordonné

Question

Ci-dessous l'image est une partie simple de l'algorithme complexe. J'essaie de préparer certaines classes en accord avec l'algorithme.

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. 
    } 
} 

Ma principale préoccupation est de gérer un grand nombre de classess vers le succès algorithm.I essayer de concevoir que les méthodes d'usine de niveau décidera quelle classe (au même niveau) doivent être instancié à ce niveau après cette usine au prochain niveau La méthode instanciée.Flow est gérée dans le constructeur des méthodes d'usine de niveau.Pensez-vous que cela est gérable, maintable? Offrez-vous une meilleure solution?

Answer 1

modèles créationnelle:

dont vous avez besoin Abstract_factory, qui retourne deux types d'usines selon vos besoins -type_list_a et type_list_b.

modèles comportementaux:

Si vous êtes à la recherche d'échange d'algorithme lors de l'exécution dynamique, vous devez utiliser Strategy_pattern avec Contexte.

Le contexte connaît et renvoie un algorithme spécifique de sorte que le client ne connaisse pas toutes les classes 100 ou 1000, qui implémentent un algorithme.

Real World Example of the Strategy Pattern fournit un bon exemple.

modèles structurels:

Si vous souhaitez masquer la complexité au client sans exposer tous les sous-systèmes, utilisez modèle Facade. Consultez les didacticiels sourcemaking pour plus de détails sur les cas d'utilisation de chaque motif.