Erstellen großer, unveränderlicher Objekte ohne Verwendung von Konstruktoren mit langen Parameterlisten

Ich habe einige große Objekte (mehr als 3 Felder), die unveränderlich sein können und sollten. Jedes Mal, wenn ich auf diesen Fall stoße, neige ich dazu, Konstruktor-Abscheulichkeiten mit langen Parameterlisten zu erstellen.

Es fühlt sich nicht richtig an, ist schwer zu bedienen und die Lesbarkeit leidet.

Es ist noch schlimmer, wenn die Felder eine Art Sammlungstyp wie Listen sind. Ein einfaches addSibling(S s)würde die Objekterstellung so sehr erleichtern, macht das Objekt jedoch veränderlich.

Was benutzt ihr in solchen Fällen?

Ich bin auf Scala und Java, aber ich denke, das Problem ist sprachunabhängig, solange die Sprache objektorientiert ist.

Lösungen, die mir einfallen:

1. "Konstruktor-Greuel mit langen Parameterlisten"
2. Das Builder-Muster

Nun, Sie möchten sowohl ein leichter lesbares als auch ein unveränderliches Objekt, sobald es erstellt wurde?

Ich denke, eine fließende Schnittstelle, die richtig gemacht wurde, würde Ihnen helfen.

Es würde so aussehen (rein erfundenes Beispiel):

final Foo immutable = FooFactory.create()
    .whereRangeConstraintsAre(100,300)
    .withColor(Color.BLUE)
    .withArea(234)
    .withInterspacing(12)
    .build();

Ich habe "RICHTIG GEMACHT" in Fettdruck geschrieben, weil die meisten Java-Programmierer fließende Schnittstellen falsch verstehen und ihr Objekt mit der zum Erstellen des Objekts erforderlichen Methode verschmutzen, was natürlich völlig falsch ist.

Der Trick ist, dass nur die build () -Methode tatsächlich ein Foo erstellt (daher kann Ihr Foo unveränderlich sein).

FooFactory.create () , wobeiXXX (..) und withXXX (..) alle "etwas anderes" erstellen.

Dass etwas anderes eine FooFactory sein kann, hier ist eine Möglichkeit, es zu tun ...

Ihre FooFactory würde so aussehen:

// Notice the private FooFactory constructor
private FooFactory() {
}

public static FooFactory create() {
    return new FooFactory();
}

public FooFactory withColor( final Color col ) {
    this.color = color;
    return this;
}

public Foo build() {
    return new FooImpl( color, and, all, the, other, parameters, go, here );
}

In Scala 2.8 können Sie benannte und Standardparameter sowie die copyMethode für eine Fallklasse verwenden. Hier ist ein Beispielcode:

case class Person(name: String, age: Int, children: List[Person] = List()) {
  def addChild(p: Person) = copy(children = p :: this.children)
}

val parent = Person(name = "Bob", age = 55)
  .addChild(Person("Lisa", 23))
  .addChild(Person("Peter", 16))

Betrachten Sie dies in Scala 2.8:

case class Person(name: String, 
                  married: Boolean = false, 
                  espouse: Option[String] = None, 
                  children: Set[String] = Set.empty) {
  def marriedTo(whom: String) = this.copy(married = true, espouse = Some(whom))
  def addChild(whom: String) = this.copy(children = children + whom)
}

scala> Person("Joseph").marriedTo("Mary").addChild("Jesus")
res1: Person = Person(Joseph,true,Some(Mary),Set(Jesus))

Dies hat natürlich einige Probleme. Versuchen Sie zum Beispiel, espouseund Option[Person]und dann zwei Personen miteinander zu heiraten. Ich kann mir keinen Weg vorstellen, das zu lösen, ohne auf einen private varund / oder einen privateKonstrukteur und eine Fabrik zurückzugreifen.

Hier sind einige weitere Optionen:

Option 1

Machen Sie die Implementierung selbst veränderbar, trennen Sie jedoch die Schnittstellen, die sie veränderbar und unveränderlich macht. Dies ist dem Design der Swing-Bibliothek entnommen.

public interface Foo {
  X getX();
  Y getY();
}

public interface MutableFoo extends Foo {
  void setX(X x);
  void setY(Y y);
}

public class FooImpl implements MutableFoo {...}

public SomeClassThatUsesFoo {
  public Foo makeFoo(...) {
    MutableFoo ret = new MutableFoo...
    ret.setX(...);
    ret.setY(...);
    return ret; // As Foo, not MutableFoo
  }
}

Option 2

Wenn Ihre Anwendung eine große, aber vordefinierte Menge unveränderlicher Objekte enthält (z. B. Konfigurationsobjekte), können Sie das Spring- Framework verwenden.

Es hilft, sich daran zu erinnern, dass es verschiedene Arten von Unveränderlichkeit gibt . Für Ihren Fall denke ich, dass die Unveränderlichkeit von "Eis am Stiel" wirklich gut funktionieren wird:

Eis am Stiel Unveränderlichkeit: ist das, was ich skurril eine leichte Schwächung der Unveränderlichkeit beim einmaligen Schreiben nenne. Man könnte sich ein Objekt oder ein Feld vorstellen, das während seiner Initialisierung für eine Weile veränderlich blieb und dann für immer „eingefroren“ wurde. Diese Art der Unveränderlichkeit ist besonders nützlich für unveränderliche Objekte, die sich kreisförmig aufeinander beziehen, oder unveränderliche Objekte, die auf die Platte serialisiert wurden und bei der Deserialisierung "flüssig" sein müssen, bis der gesamte Deserialisierungsprozess abgeschlossen ist. An diesem Punkt können sich alle Objekte befinden gefroren.

Sie initialisieren also Ihr Objekt und setzen dann ein "Freeze" -Flag, das angibt, dass es nicht mehr beschreibbar ist. Am besten verstecken Sie die Mutation hinter einer Funktion, damit die Funktion für Clients, die Ihre API verwenden, immer noch rein ist.

Sie können die unveränderlichen Objekte auch Methoden verfügbar machen, die wie Mutatoren aussehen (wie addSibling), sie jedoch eine neue Instanz zurückgeben lassen. Das machen die unveränderlichen Scala-Sammlungen.

Der Nachteil ist, dass Sie möglicherweise mehr Instanzen als erforderlich erstellen. Dies gilt auch nur, wenn zwischenzeitlich gültige Konfigurationen vorhanden sind (wie bei einigen Knoten ohne Geschwister, was in den meisten Fällen in Ordnung ist), es sei denn, Sie möchten sich nicht mit teilweise erstellten Objekten befassen.

Beispielsweise ist eine Diagrammkante, die noch kein Ziel hat, keine gültige Diagrammkante.

Betrachten Sie vier Möglichkeiten:

new Immutable(one, fish, two, fish, red, fish, blue, fish); /*1 */

params = new ImmutableParameters(); /*2 */
params.setType("fowl");
new Immutable(params);

factory = new ImmutableFactory(); /*3 */
factory.setType("fish");
factory.getInstance();

Immutable boringImmutable = new Immutable(); /* 4 */
Immutable lessBoring = boringImmutable.setType("vegetable");

Für mich ist jeder von 2, 3 und 4 an eine unterschiedliche Situation angepasst. Der erste ist aus den vom OP angeführten Gründen schwer zu lieben und ist im Allgemeinen ein Symptom für ein Design, das ein gewisses Kriechen erlitten hat und etwas umgestaltet werden muss.

Was ich als (2) aufführe, ist gut, wenn es keinen Zustand hinter der 'Fabrik' gibt, während (3) das Design der Wahl ist, wenn es einen Zustand gibt. Ich verwende (2) anstelle von (3), wenn ich mich nicht um Threads und Synchronisation kümmern möchte, und ich muss mich nicht darum kümmern, ein teures Setup über die Produktion vieler Objekte zu amortisieren. (3) wird dagegen aufgerufen, wenn echte Arbeit in den Bau der Fabrik fließt (Einrichten von einem SPI, Lesen von Konfigurationsdateien usw.).

Schließlich erwähnte die Antwort eines anderen die Option (4), bei der Sie viele kleine unveränderliche Objekte haben und das bevorzugte Muster darin besteht, Nachrichten von alten zu erhalten.

Beachten Sie, dass ich kein Mitglied des 'Pattern Fan Clubs' bin - sicher, einige Dinge sind es wert, nachgeahmt zu werden, aber es scheint mir, dass sie ein nicht hilfreiches Eigenleben führen, wenn die Leute ihnen Namen und lustige Hüte geben.

Eine weitere mögliche Option ist die Umgestaltung, um weniger konfigurierbare Felder zu haben. Wenn Gruppen von Feldern (meistens) nur miteinander arbeiten, sammeln Sie sie zu einem eigenen kleinen unveränderlichen Objekt. Die Konstruktoren / Builder dieses "kleinen" Objekts sollten besser zu verwalten sein, ebenso wie der Konstruktor / Builder für dieses "große" Objekt.

Ich benutze C # und das sind meine Ansätze. Erwägen:

class Foo
{
    // private fields only to be written inside a constructor
    private readonly int i;
    private readonly string s;
    private readonly Bar b;

    // public getter properties
    public int I { get { return i; } }
    // etc.
}

Option 1. Konstruktor mit optionalen Parametern

public Foo(int i = 0, string s = "bla", Bar b = null)
{
    this.i = i;
    this.s = s;
    this.b = b;
}

Verwendet als z new Foo(5, b: new Bar(whatever)). Nicht für Java- oder C # -Versionen vor 4.0. Es lohnt sich jedoch zu zeigen, dass nicht alle Lösungen sprachunabhängig sind.

Option 2. Konstruktor, der ein einzelnes Parameterobjekt verwendet

public Foo(FooParameters parameters)
{
    this.i = parameters.I;
    // etc.
}

class FooParameters
{
    // public properties with automatically generated private backing fields
    public int I { get; set; }
    public string S { get; set; }
    public Bar B { get; set; }

    // All properties are public, so we don't need a full constructor.
    // For convenience, you could include some commonly used initialization
    // patterns as additional constructors.
    public FooParameters() { }
}

Anwendungsbeispiel:

FooParameters fp = new FooParameters();
fp.I = 5;
fp.S = "bla";
fp.B = new Bar();
Foo f = new Foo(fp);`

C # ab 3.0 macht dies mit der Objektinitialisierersyntax eleganter (semantisch äquivalent zum vorherigen Beispiel):

FooParameters fp = new FooParameters { I = 5, S = "bla", B = new Bar() };
Foo f = new Foo(fp);

Option 3:
Gestalten Sie Ihre Klasse neu, um nicht so viele Parameter zu benötigen. Sie können die Verantwortlichkeiten in mehrere Klassen aufteilen. Oder übergeben Sie Parameter bei Bedarf nicht an den Konstruktor, sondern nur an bestimmte Methoden. Nicht immer lebensfähig, aber wenn es so ist, lohnt es sich.