Design patterns 如何控制/协调算法

下图是复杂算法的一个简单部分。 我试着根据算法准备一些课程

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

抽象类人物
{
公共字符串HasXRecords{get；set；}
public int PersonAnotherFeature{get；set；}
公共列表Xs{get；set；}=new List（）；
}
抽象类X
{
//将有1000多个类型subX类
}
接口适配器
{
void AddXToList（）；
}
接口IRemover
{
void RemoveXFromList（）；
}
类XAdderFactory
{
私人(私人),；
公共学校的人事记录
{
得到
{
返回字符串.IsNullOrEmpty（_person.HasXRecords）；
}
}
公共XAdderFactory（个人）
{
这个人；
if（个人无记录）
{
新成立的部门（人）；
}
其他的
{
新的XListMakerB（人）；
}
}
}
类XListMakerB:IAdder
{
私人(私人),；
公共XListMakerB（个人）
{
这个人；
AddXToList（）；
新人员估价员（人）；
}
public void AddXToList（）
{
//X的动态实例将添加到person Xlist中。
}
}
类别XListMakerAFactory
{
公共XListMakerAFactory（个人）
{
开关（person.PersonAnotherFeature）
{
案例1：新的XListMakerA1（人）；
打破
//将有XListMakerA2、XListMakerA3等。
}
新工厂（人）；
}
}
类别XListMakerA1:IAdder
{
私人(私人),；
公共XListMakerA1（人）
{
这个人；
AddXToList（）；
新人员估价员（人）；
}
public void AddXToList（）
{
//_person.Xs.Add（新的X1（））；
//根据业务逻辑，手工增加X2、X3等。
}
}
第X类工厂
{
公用厂房（人）
{
新名单1（人）；
新名单2（人）；
}
}
类XRemoveFromList1:IRemover
{
私人(私人),；
公共XRemoveFromList1（个人）
{
这个人；
RemoveXFromList（）；
}
public void RemoveXFromList（）
{
//根据某些业务逻辑，某些X将被删除。
}
}
XRemoveFromList2类：IRemover
{
私人(私人),；
公共XRemoveFromList2（个人）
{
这个人；
RemoveXFromList（）；
}
public void RemoveXFromList（）
{
//根据某些业务逻辑，某些X将被删除。
}
}
类PersonXListEvaluator
{
公共人员列表评估员（个人）
{
//将根据业务规则进行评估。
}
}

我主要关心的是如何管理大量的类以使算法成功。我试图设计一个级别工厂方法，在下一个级别工厂方法实例化之后，该级别工厂方法将决定必须在该级别实例化哪个类（在同一级别）。流在级别工厂方法的构造函数中进行管理。您认为这是可管理的吗，maintable？您提供更好的解决方案吗？

创意模式：

您需要as，它根据您的需求返回两种类型的工厂—类型a和类型b

行为模式：

如果您希望在运行时动态地交换算法，那么应该与上下文一起使用

上下文知道并返回特定的算法，所以客户端不知道实现算法的所有100或1000个类

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

这是一个很好的例子

结构模式：

如果希望在不公开所有子系统的情况下向客户机隐藏复杂性，请使用模式

---

有关每种模式的用例的更多详细信息，请参阅教程。

这看起来像一个问题。我找到了此链接，感谢您的回答。再次感谢。我查看了Facade，我认为Facade就是我要找的。请小心Wikipedia关于Abstract Factory的文章。它包含正确和错误信息的混合。特别是，第一个类图以及C#和Java示例是不正确的。更好的资源是：、和。维基百科不是学习设计模式的好资源，因为它是由非技术作者编辑的。