创建一个基本流利的有序构造函数

Question

编辑： 好吧，好像例子没用……

我有一个有序的流式构造函数，它对许多对象都是通用的（都具有相同的属性）。有没有办法将所有代码放在同一个基工厂类中，而派生工厂中只有最终的构造函数？

我使用这样的构造函数

.InitCreation()
.WithID()
.WithPoperty1()
.Create()

只有 Create() 创建新对象，ID 是必填字段。

泛型似乎我需要重写所有工厂中的所有方法，而我只想重写 Create() 方法以返回正确的对象。

另一种方法是在 fluent 构造函数中授予必填字段，而不使用有序的 fluent，但找不到什么可做的

EDIT2

基础工厂：

    namespace FunzIA.DL.Factory
{
    public class BaseObjectFactory : IBaseObjectCreated, IBaseObjectWithMandatoryField1, IBaseObjectWithFields
{
    internal int mandatoryField1 { get; set; }
    internal string mandatoryField12 { get; set; }
    internal bool optionaField1 { get; set; }

    private BaseObjectFactory(){}

    public static IBaseObjectCreated InitCreation()
    {return new BaseObjectFactory(); }

    public IBaseObjectWithMandatoryField1 WithMandatoryField1(int number)
    {
        mandatoryField1 = number;
        return this;
    }

    public IBaseObjectWithFields ConmandatoryField12(string text)
    {
        mandatoryField12 = text;
        return this;
    }

    public IBaseObjectWithFields optionaField1(bool optionaField1P)
    {
        optionaField1 = optionaField1P;
        return this;
    }

    public BaseObject Create()
    {return new BaseObject(this);}
}



public interface IBaseObjectCreated
{IBaseObjectWithMandatoryField1 WithMandatoryField1(int number);}

public interface IBaseObjectWithMandatoryField1 
{IBaseObjectWithFields ConmandatoryField12(string text);}

public interface IBaseObjectWithFields
{
    IBaseObjectWithFields optionaField1(bool optionaField1);
    BaseObject Create();
}
}

---

老例子

我以这种方式创建了一个类Struttura：

namespace FunzIA.DL.Oggetti
{
public class Struttura
{
    public int IdStruttura { get; set; }
    public string Descrizione { get; set; }
    public bool Annullato { get; set; }

    private Struttura(){}
    public Struttura(StrutturaFactory factory)
    {
        IdStruttura = factory.idStruttura;
        Descrizione = factory.descrizione;
        Annullato = factory.annullato;
    }   
}
}

他的Fuent Constructori是这样的：

namespace FunzIA.DL.Factory
{
    public class StrutturaFactory : IStrutturaCeato, IStrutturaConChiave, IStrutturaConProprieta
{
    internal int idStruttura { get; set; }
    internal string descrizione { get; set; }
    internal bool annullato { get; set; }
    internal IList<Processo> processi { get; set; }

    private StrutturaFactory(){}

    public static IStrutturaCeato IniziaCreazione()
    {return new StrutturaFactory(); }

    public IStrutturaConChiave ConCodice(int codiceP)
    {
        idStruttura = codiceP;
        return this;
    }

    public IStrutturaConProprieta ConDescrizione(string nome)
    {
        descrizione = nome;
        return this;
    }

    public IStrutturaConProprieta Annullato(bool annullatoP)
    {
        annullato = annullatoP;
        return this;
    }

    public Struttura Crea()
    {return new Struttura(this);}
}



public interface IStrutturaCeato 
{IStrutturaConChiave ConCodice(int chiave);}

public interface IStrutturaConChiave 
{IStrutturaConProprieta ConDescrizione(string nome);}

public interface IStrutturaConProprieta
{
    IStrutturaConProprieta Annullato(bool annullato);
    IStrutturaConProprieta ConProcessi(IList<Processo> processi);
    Struttura Crea();
}
}

这样我就可以这样写构造函数了

Struttura actual = StrutturaFactory.IniziaCreazione()
                                .ConCodice(1)
                                .ConDescrizione("MiaDescrizione")
                                .Crea();

但是现在我看到我有许多具有相似字段（ID、描述、取消）的对象，所以我尝试编写一个通用的流式构造函数：

namespace FunzIA.DL
{
public class OggettoBaseFactory : IOggettoBaseCeato, IOggettoBaseConChiave, IOggettoBaseConProprieta
{
    internal int id { get; set; }
    internal string descrizione { get; set; }
    internal bool annullato { get; set; }

    private OggettoBaseFactory(){}

    public static IOggettoBaseCeato IniziaCreazione()
    {return new OggettoBaseFactory();}

    public IOggettoBaseConChiave ConCodice(int codiceP)
    {
        id = codiceP;
        return this;
    }

    public IOggettoBaseConProprieta ConDescrizione(string nome)
    {
        descrizione = nome;
        return this;
    }

    public IOggettoBaseConProprieta Annullato(bool annullatoP)
    {
        annullato = annullatoP;
        return this;
    }

    public OggettoBase Crea()
    {return null;}
}



public interface IOggettoBaseCeato 
{IOggettoBaseConChiave ConCodice(int chiave);}

public interface IOggettoBaseConChiave 
{IOggettoBaseConProprieta ConDescrizione(string nome);}

public interface IOggettoBaseConProprieta
{
    IOggettoBaseConProprieta Annullato(bool annullato);
    OggettoBase Crea();
}
}

并修改我的工厂

namespace FunzIA.DL.Factory
{
    public class StrutturaFactory : OggettoBaseFactory
    {
        public Struttura Crea()
        {return new Struttura(this);}
    }
}

但是现在当我写 Struttura 实际 = StrutturaFactory.IniziaCreazione() .ConCodice(idExpected) .ConDescrizione（描述预期） .Annullato(annullatoExpected) .Crea();

我得到这个错误：

错误 5 无法将类型“FunzIA_DL.OggettoBase”隐式转换为“FunzIA.DL.Oggetti.Struttura”。存在显式转换（您是否缺少演员表？）

有没有办法做到这一点，或者我必须在所有流利的构造函数中重写相同的逻辑？

Answer 1

像这样投射它：

Struttura actual = (Struttura)StrutturaFactory.IniziaCreazione() .ConCodice(idExpected) .ConDescrizione(descrizioneExpected) .Annullato(annullatoExpected) .Crea();

Answer 2

我在 BaseFactory 中以这种方式使用泛型解决了：

public T Create<T>()
        {
            return (T)Activator.CreateInstance(typeof(T), this);
        }

那么我的 DerivedFactory 就是这样的：

namespace FunzIA.DL.Factory
{
    public class SocietyFactory : BaseFactory
    {}
}

所以我可以写

Society actual = SocietyFactory.InitCreation()
                    .WithCode(idExpected)
                    .Create<Societa>();