创建基本流利有序构造函数 [英] Create a base fluent ordered constructor

问题描述

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

我有一个有序流利的构造函数，很多对象是共同的属性）。有没有办法把所有的代码放在同一个基类工厂类中，只有最终的构造函数在派生工厂？

我使用这样的构造函数

  .InitCreation（）
 .WithID（）
 .WithPoperty1（）
 .Create $ b 

其中只有Create（）创建新对象，ID是必填字段。

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

其他方法是在流利的构造函数中授予必填字段，而不使用有序的流利，但是找不到任何东西。

EDIT2

baseFactory：

 命名空间FunzIA.DL.Factory 
 {
 public class BaseObjectFactory：IBaseObjectCreated，IBaseObjectWithMandatoryField1，IBaseObjectWithFields 
 {
 internal int mandatoryField1 {get;组; } 
 internal string mandatoryField12 {get;组; } 
 internal bool optionaField1 {get;组; } 
 
 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;组; } 
 public string Descrizione {get;组; } 
 public bool Annullato {get;组; } 
 
 private Struttura（）{} 
 public Struttura（StrutturaFactory factory）
 {
 IdStruttura = factory.idStruttura; 
 Descrizione = factory.descrizione; 
 Annullato = factory.annullato; 
} 
} 
} 
  

：

 命名空间FunzIA.DL.Factory 
 {
 public class StrutturaFactory：IStrutturaCeato，IStrutturaConChiave，IStrutturaConProprieta 
 {
 internal int idStruttura {get;组; } 
 internal string descrizione {get;组; } 
 internal bool annullato {get;组; } 
 internal IList< Processo> processi {get;组; } 
 
 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（）; 
  

但现在我看到有很多对象具有类似的字段尝试写一个公共流利的构造函数：

 命名空间FunzIA.DL 
 {
 public class OggettoBaseFactory：IOggettoBaseCeato ，IOggettoBaseConChiave，IOggettoBaseConProprieta 
 {
 internal int id {get;组; } 
 internal string descrizione {get;组; } 
 internal bool annullato {get;组; } 
 
 private OggettoBaseFactory（）{} 
 
 public static IOggettoBaseCeato IniziaCreazione（）
 {return new OggettoBaseFactory（）;} 
 
 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;} 
} 
 
 
 
 IOggettoBaseCeato 
 {IOggettoBaseConChiave ConCodice（int chiave）;} 
 
公共接口IOggettoBaseConProprieta $公共接口IOggettoBaseConPeedeta 
 {
 IOggettoBaseConProprieta Annullato（bool annullato）; 
 OggettoBase Crea（）; 
} 
} 
  

并修改我的工厂

 命名空间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。显式转换存在（是否缺少转换？）

是否有办法或者必须重写相同的逻辑

解决方案

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

public T Create< T>（）
{
return（T）Activator.CreateInstance（typeof（T），this）;
}


那么我的DerivedFactory就是这样：

 命名空间FunzIA.DL.Factory 
 {
 public class SocietyFactory：BaseFactory 
 {} 
} 
  

所以我可以写

  Society actual = SocietyFactory.InitCreation（）
 .WithCode（idExpected）
 .Create< Societa>（）; 
  

EDIT: Ok, seem example is unuseful...

I have an ordered fluent constructor that is common to many object (all have tha same properties). Is there a way to put all the code in the same base factory class and have only the final costructor in the derived factory?

I use constructor like this

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

where only the Create() make the new object and ID is a mandatory field.

Generics seem me to need rewriting all methods in all factory, instead i want to rewrite only the Create() method to return the right object.

Other way is to grant mandatory field in fluent constructor without using an ordered fluent but don't find nothing to do it

EDIT2

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

---

The old Example

i create a class Struttura in this way:

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

And his Fuent Constructori is this:

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

In this way i can write constructor in this way

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

But now i see that i have many object with similar fields (ID, description, canceled) so i try to write a common fluent constructor:

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

And modify my Factory

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

But now when i write Struttura actual = StrutturaFactory.IniziaCreazione() .ConCodice(idExpected) .ConDescrizione(descrizioneExpected) .Annullato(annullatoExpected) .Crea();

i get this error:

Error 5 Cannot implicitly convert type 'FunzIA_DL.OggettoBase' to 'FunzIA.DL.Oggetti.Struttura'. An explicit conversion exists (are you missing a cast?)

Is there a way to do it or i have to rewrite the same logic in all my fluent constructor?

解决方案

I solved using Generics in this way in the BaseFactory:

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

then my DerivedFactory is simply this:

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

so i can write

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

这篇关于创建基本流利有序构造函数的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！