Question

编辑：好吧，似乎例子是无用的......

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

我使用像这样的构造函数

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

只有Create（）使新对象和ID成为必填字段。

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

其他方法是在不使用有序流利的情况下在流畅的构造函数中授予必填字段但是没有找到任何操作

EDIT2

baseFactory：

    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 actual = StrutturaFactory.IniziaCreazione（） .ConCodice（idExpected） .ConDescrizione（descrizioneExpected） .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中以这种方式使用Generics解决了：

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>();

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

2 个答案: