moin, > > Frisst das nicht soviele system resourcen wenn bei jedem Methoden aufgruf der Builder-Klasse alls Klassen Validatoren übergeben werden damit der Construction eine rauspcken kann, validieren und zurück schicken kann??? > > Du übergibtst doch Referenzen. MFG Ja, Referenz der Instanzen und zwar jedes Mal. Die _RefinedAbstraction_ (sprich hier der **FooConstruction**) nimmt die Instanz-Gruppe der **Validator**en entgegegen und zerstört sie nach dem herraus Picken eines **Validator**s und dem validieren. Meines erachtens nach, teuer und ein unnötiger Aufwand, für mich starre Kopplung. Ich wollte einfach nur wissen obs da nicht ne performantere Möglichkeit gibt, das anstehende Problem eleganter zu lösen. lgmb _PS: Ich muss noch dazu sagen, dass es verhältnismäßig wenig **Validator**en sind. 0 bis 5 Klassen **Validator**en. Kann man das verkraften??? Wenn zukünfig ein größeres Projekt ansteht, mit dem Bridge Design Pattern und ein ähnliches Problem mit extrem vielen übergebenden Klassen (hier die **Validator**en) auftritte, wollte ich wissen obs da nicht eleganteren Weg gibt._

moin, > > Frisst das nicht soviele system resourcen wenn bei jedem Methoden aufgruf der Builder-Klasse alls Klassen Validatoren übergeben werden damit der Construction eine rauspcken kann, validieren und zurück schicken kann??? > > Du übergibtst doch Referenzen. MFG Ja, Referenz der Instanzen und zwar jedes Mal. Die _RefinedAbstraction_ (sprich hier der **FooConstruction**) nimmt die Instanz-Gruppe der **Validator**en entgegegen und zerstört sie nach dem herraus Picken eines **Validator**s und dem validieren. Meines erachtens nach, teuer und ein unnötiger Aufwand, für mich starre Kopplung. Ich wollte einfach nur wissen obs da nicht ne performantere Möglichkeit gibt, das anstehende Problem eleganter zu lösen. lgmb _PS: Ich muss noch dazu sagen, dass es verhältnismäßig wenig **Validator**en sind. 0 bis 5 Klassen **Validator**en. Kann man das verkraften??? Wenn zukünfig ein größeres Projekt ansteht, mit dem Bridge Design Pattern und ein ähnliches Problem mit extrem vielen übergebenden Klassen (hier die **Validatort**en) auftritte, wollte ich wissen obs da nicht eleganteren Weg gibt._

moin, > > Frisst das nicht soviele system resourcen wenn bei jedem Methoden aufgruf der Builder-Klasse alls Klassen Validatoren übergeben werden damit der Construction eine rauspcken kann, validieren und zurück schicken kann??? > > Du übergibtst doch Referenzen. MFG Ja, Referenz der Instanzen und zwar jedes Mal. Die _RefinedAbstraction_ (sprich hier der **FooConstruction**) nimmt die Instanz-Gruppe der **Validator**en entgegegen und zerstört sie nach dem herraus Picken eines **Validator**s und dem validieren. Meines erachtens nach, teuer und ein unnötiger Aufwand, für mich starre Kopplung. Ich wollte einfach nur wissen obs da nicht ne performantere Möglichkeit gibt, das anstehende Problem eleganter zu lösen. lgmb _PS: Ich muss noch dazu sagen, dass es verhältnismäßig wenig **Validator**en sind. 0 bis 5 Klassen **Validator**en. Kann man das verkraften??? Jedoch wenn zukünfig ein größeres Projekt ansteht, mit dem Bridge Design Pattern und ein ähnliches Problem mit extrem vielen übergebenden Klassen (hier die **Validatort**en) auftritte, wollte ich wissen obs da nicht eleganteren Weg gibt._

moin, > > Frisst das nicht soviele system resourcen wenn bei jedem Methoden aufgruf der Builder-Klasse alls Klassen Validatoren übergeben werden damit der Construction eine rauspcken kann, validieren und zurück schicken kann??? > > Du übergibtst doch Referenzen. MFG Ja, Referenz der Instanzen und zwar jedes Mal. Die _RefinedAbstraction_ (sprich hier der **FooConstruction**) nimmt die Instanz-Gruppe der **Validator**en entgegegen und zerstört sie nach dem herraus Picken eines **Validator**s und dem validieren. Meines erachtens nach, teuer und ein unnötiger Aufwand, für mich starre Kopplung. Ich wollte einfach nur wissen obs da nicht ne performantere Möglichkeit gibt, das anstehende Problem eleganter zu lösen. lgmb _PS: Ich muss noch dazu sagen, dass es verhältnismäßig wenig **Validator**en sind. 0 bis 5 Klassen **Validator**en. Kann man das verkraften??? Aber wenn ein größeres Projekt ansteht mit dem Bridge Design Pattern und ein ähnliches Problem mit extrem vielen übergebenden Klassen (hier die **Validatort**en) auftritte, wollte ich wissen obs da niocht eleganzeren Weg gibt._

moin, > > Frisst das nicht soviele system resourcen wenn bei jedem Methoden aufgruf der Builder-Klasse alls Klassen Validatoren übergeben werden damit der Construction eine rauspcken kann, validieren und zurück schicken kann??? > > Du übergibtst doch Referenzen. MFG Ja, Referenz der Instanzen und zwar jedes Mal. Die _RefinedAbstraction_ (sprich hier der **FooConstruction**) nimmt die Instanz-Gruppe der **Validator**en entgegegen und zerstört sie nach dem herraus Picken eines **Validator**s und dem validieren. Meines erachtens nach, teuer und ein unnötiger Aufwand, für mich starre Kopplung. Ich wollte einfach nur wissen obs da nicht ne performantere Möglichkeit gibt, das anstehende Problem eleganter zu lösen. lgmb _PS: Ich muss noch dazu sagen, dass es verhältnismäßig wenig **Validator**en sind. 0 bis 5 Klassen **Validator**en. Kann man das verkraften??? Aber wenn ein größeres Projekt ansteht mit dem Bridge Design Pattern und ein ähnliches Problem mit extrem vielen übergebenden Klassen (hier die **Validatort**en) auftritte, wollte ich wissen