Was ist besser: ein Haufen Getter oder eine Methode mit einem Auswahlstringparameter?

Unser Wissensgebiet umfasst Menschen, die mit bloßen Füßen über eine Druckplatte laufen. Wir machen eine Bilderkennung, die Objekte der Klasse 'Fuß' ergibt, wenn ein menschlicher Fuß in den Sensordaten erkannt wird.

Es gibt verschiedene Berechnungen, die an den Daten des Fußes durchgeführt werden müssen.

Nun, welche API wäre besser:

class Foot : public RecognizedObject  { 
  MaxPressureFrame getMaxPressureFrame();
  FootAxis getFootAxis();
  AnatomicalZones getAnatomicalZones();

  // + similar getters for other calculations

  // ...
}

Oder:

class Foot : public RecognizedObject {
  virtual CalculationBase getCalculation(QString aName);

  // ...
}

Nun gibt es eine Menge Vor- und Nachteile, die ich mir einfallen lassen kann, aber ich kann mich nicht wirklich entscheiden, welche die wichtigsten sind. Hinweis: Dies ist eine Endbenutzeranwendung, keine von uns verkaufte Softwarebibliothek.

Irgendein Rat?

Einige Profis für den ersten Ansatz könnten sein:

• KISS - alles ist sehr konkret. Die API, aber auch die Implementierung.
• stark typisierte Rückgabewerte.
• Das Erben von dieser Klasse ist narrensicher. Nichts kann überschrieben, nur hinzugefügt werden.
• API ist sehr geschlossen, nichts geht rein, nichts kann überschrieben werden, so dass weniger schief gehen kann.

Einige Con's:

• Die Anzahl der Getter wird zunehmen, da jede neue Berechnung, die wir erfinden, zur Liste hinzugefügt wird
• Es ist wahrscheinlicher, dass sich die API ändert. Wenn wichtige Änderungen vorgenommen werden, benötigen wir eine neue API-Version, Foot2.
• Im Falle der Wiederverwendung der Klasse in anderen Projekten benötigen wir möglicherweise nicht jede Berechnung

Einige Profis für den zweiten Ansatz:

• flexibler
• Es ist weniger wahrscheinlich, dass sich die API ändert (vorausgesetzt, wir haben die richtige Abstraktion, wenn nicht, kostet eine Änderung mehr).

Einige Con's:

• lose getippt. Muss bei jedem Anruf besetzt werden.
• der String-Parameter - ich habe schlechte Gefühle darüber (Verzweigung auf String-Werte ...)
• Es gibt keinen aktuellen Anwendungsfall / keine aktuelle Anforderung, die die zusätzliche Flexibilität vorschreibt, aber möglicherweise in der Zukunft.
• Die API legt Einschränkungen fest: Jede Berechnung muss von einer Basisklasse abgeleitet werden. Das Erhalten einer Berechnung wird durch diese 1 Methode erzwungen, und das Übergeben zusätzlicher Parameter wird unmöglich sein, es sei denn, wir entwickeln eine noch dynamischere, superflexible Methode zum Übergeben von Parametern, die die Komplexität noch weiter erhöht.

Ich denke im ersten Ansatz wird sich auszahlen. Magische Zeichenfolgen können die folgenden Probleme verursachen: Tippfehler, Missbrauch, nicht triviale Sicherheit beim Zurückgeben, fehlende Code-Vervollständigung, unklarer Code (hatte diese Version diese Funktion? Ich denke, wir werden es zur Laufzeit herausfinden). Durch die Verwendung von Aufzählungen werden einige dieser Probleme behoben. Sehen wir uns jedoch die Nachteile an, die Sie angesprochen haben:

• Die Anzahl der Getter wird zunehmen, da jede neue Berechnung, die wir erfinden, zur Liste hinzugefügt wird

Das kann zwar ärgerlich sein, hält aber die Dinge schön und streng und gibt Ihnen überall in Ihrem Projekt in einer modernen IDE Code-Vervollständigung mit guten Überschriften-Kommentaren, die viel nützlicher sind als Aufzählungen.

• Es ist wahrscheinlicher, dass sich die API ändert. Wenn wichtige Änderungen vorgenommen werden, benötigen wir eine neue API-Version, Foot2.

Stimmt, aber das ist eigentlich ein riesiger Profi;) Sie können Schnittstellen für Teil-APIs definieren und müssen dann keine abhängigen Klassen neu kompilieren, die nicht von neueren APIs betroffen sind (also kein Foot2 erforderlich). Das ermöglicht eine bessere Entkopplung, die Abhängigkeit ist jetzt von der Schnittstelle und nicht von der Implementierung. Darüber hinaus tritt bei Änderungen an einer vorhandenen Schnittstelle in abhängigen Klassen ein Kompilierungsfehler auf. Dies ist hilfreich, um veralteten Code zu vermeiden.

• Im Falle der Wiederverwendung der Klasse in anderen Projekten benötigen wir möglicherweise nicht jede Berechnung

Ich verstehe nicht, wie die Verwendung von magischen Zeichenfolgen oder Aufzählungen dabei helfen wird. Wenn ich das richtig verstehe, fügen Sie entweder den Code in die Foot-Klasse ein oder unterteilen ihn in ein paar kleinere Klassen. Dies gilt für beide Optionen

Ich würde Option 3 empfehlen: Stellen Sie klar, dass die Berechnungen kein wesentlicher Bestandteil der Abstraktion von a sind Foot, sondern darauf basieren . Dann können Sie Footdie Berechnungen wie folgt in separate Klassen aufteilen :

class Foot : public RecognizedObject {
public:
    // Rather low-level API to access all characteristics that might be needed by a calculation
};

class MaxPressureFrame {
public:
    MaxPressureFrame(const Foot& aFoot); // Performs the calculation based on the information in aFoot
    //API for accessing the results of the calculation
};

// Similar classes for other calculations

Auf diese Weise haben Sie immer noch eine starke Typisierung Ihrer Berechnung und können neue hinzufügen, ohne den vorhandenen Code zu beeinträchtigen (es sei denn, Sie haben einen schwerwiegenden Fehler bei den von bereitgestellten Betragsinformationen gemacht Foot).