Wie bearbeite ich eine Kette von if-else if-Anweisungen, um die Clean Code-Prinzipien von Onkel Bob einzuhalten?

Ich versuche, den sauberen Codevorschlägen von Onkel Bob zu folgen und Methoden kurz zu halten.

Ich bin jedoch nicht in der Lage, diese Logik zu verkürzen:

if (checkCondition()) {addAlert(1);}
else if (checkCondition2()) {addAlert(2);}
else if (checkCondition3()) {addAlert(3);}
else if (checkCondition4()) {addAlert(4);}

Ich kann die anderen nicht entfernen und so das Ganze in kleinere Teile zerlegen, weil das "sonst" im "sonst wenn" die Leistung verbessert - die Bewertung dieser Bedingungen ist teuer, und wenn ich vermeiden kann, die folgenden Bedingungen zu bewerten, eine der ersten verursachen ist wahr, ich möchte sie vermeiden.

Auch semantisch gesehen macht es aus betriebswirtschaftlicher Sicht keinen Sinn, die nächste Bedingung zu bewerten, wenn die vorherige erfüllt wurde.

Bearbeiten: Diese Frage wurde als ein mögliches Duplikat von Elegant-Methoden für den Umgang mit if (if else) else identifiziert .

Ich glaube, das ist eine andere Frage (das sieht man auch, wenn man die Antworten dieser Fragen vergleicht).

• Meine Frage lautet, ob die erste akzeptierende Bedingung schnell endet .
• Die verknüpfte Frage versucht, alle Bedingungen zu akzeptieren , um etwas zu tun. (Besser in dieser Antwort auf diese Frage zu sehen: https://softwareengineering.stackexchange.com/a/122625/96955 )

Idealerweise sollten Sie Ihre Logik extrahieren, um den Warnungscode / die Warnungsnummer in eine eigene Methode umzuwandeln. So wird Ihr bestehender Code auf das Wesentliche reduziert

{
    addAlert(GetConditionCode());
}

und GetConditionCode () kapselt die Logik zum Überprüfen von Bedingungen. Vielleicht ist es auch besser, eine Aufzählung als eine magische Zahl zu verwenden.

private AlertCode GetConditionCode() {
    if (CheckCondition1()) return AlertCode.OnFire;
    if (CheckCondition2()) return AlertCode.PlagueOfBees;
    if (CheckCondition3()) return AlertCode.Godzilla;
    if (CheckCondition4()) return AlertCode.ZombieSharkNado;
    return AlertCode.None;
}

Das wichtige Maß ist die Komplexität des Codes, nicht die absolute Größe. Unter der Annahme, dass die verschiedenen Bedingungen nur einzelne Funktionsaufrufe sind und die Aktionen nicht komplexer sind als die von Ihnen gezeigten, würde ich sagen, dass am Code nichts falsch ist. Es ist schon so einfach wie es sein kann.

Jeder Versuch einer weiteren "Vereinfachung" wird die Dinge in der Tat komplizieren.

Natürlich können Sie das elseSchlüsselwort durch ein ersetzen, returnwie andere vorgeschlagen haben, aber das ist nur eine Frage des Stils, nicht der Komplexität.

Beiseite:

Mein allgemeiner Rat wäre, niemals religiös über eine Regel für sauberen Code zu werden: Die meisten Codierungsratschläge, die Sie im Internet sehen, sind gut, wenn sie in einem passenden Kontext angewendet werden, aber wenn Sie diese Ratschläge radikal überall anwenden, können Sie einen Einstieg gewinnen die IOCCC . Der Trick ist immer, ein Gleichgewicht zu finden, das es den Menschen ermöglicht, leicht über Ihren Code nachzudenken.

Verwenden Sie zu große Methoden, und Sie sind geschraubt. Verwenden Sie zu kleine Funktionen, und Sie sind geschraubt. Vermeiden Sie ternäre Ausdrücke, und Sie sind geschraubt. Verwenden Sie überall ternäre Ausdrücke, und Sie sind geschraubt. Stellen Sie fest, dass es Orte gibt, die einzeilige Funktionen erfordern, und Orte, die Funktionen mit 50 Zeilen erfordern (ja, sie existieren!). Stellen Sie fest, dass es Stellen gibt, an denen if()Anweisungen erforderlich sind , und Orte, an denen der ?:Operator erforderlich ist. Nutzen Sie das gesamte Arsenal, das Ihnen zur Verfügung steht, und versuchen Sie immer, das am besten geeignete Werkzeug zu verwenden, das Sie finden können. Und denken Sie daran, auch bei diesem Rat nicht religiös zu werden.

Es ist umstritten, ob dies für einen bestimmten Fall "besser" ist als die Ebene if..else. Aber wenn Sie wollen etwas anderes versuchen dies ist ein gemeinsamer Weg , es zu tun.

Fügen Sie Ihre Bedingungen in Objekte ein und fügen Sie diese Objekte in eine Liste ein

foreach(var condition in Conditions.OrderBy(i=>i.OrderToRunIn))
{
    if(condition.EvaluatesToTrue())
    {
        addAlert(condition.Alert);
        break;
    }
}

Wenn mehrere Aktionen erforderlich sind, können Sie eine verrückte Rekursion durchführen

void RunConditionalAction(ConditionalActionSet conditions)
{
    foreach(var condition in conditions.OrderBy(i=>i.OrderToRunIn))
    {
        if(condition.EvaluatesToTrue())
        {
            RunConditionalAction(condition);
            break;
        }
    }
}

Natürlich ja. Dies funktioniert nur, wenn Sie ein Muster für Ihre Logik haben. Wenn Sie versuchen, eine super-generische rekursive bedingte Aktion auszuführen, ist das Setup für das Objekt so kompliziert wie die ursprüngliche if-Anweisung. Sie erfinden Ihre eigene neue Sprache / Framework.

Aber Ihr Beispiel hat ein Muster

Ein häufiger Anwendungsfall für dieses Muster wäre die Validierung. Anstatt :

bool IsValid()
{
    if(condition1 == false)
    {
        throw new ValidationException("condition1 is wrong!");
    }
    elseif(condition2 == false)
    {
    ....

}

Wird

[MustHaveCondition1]
[MustHaveCondition2]
public myObject()
{
    [MustMatchRegExCondition("xyz")]
    public string myProperty {get;set;}
    public bool IsValid()
    {
        conditions = getConditionsFromReflection()
        //loop through conditions
    }
}

Ziehen Sie in Betracht, return;nach dem Erfolg einer Bedingung alle elses zu sparen . Möglicherweise können Sie sogar return addAlert(1)direkt, wenn diese Methode einen Rückgabewert hat.

Ich habe Konstruktionen wie diese gesehen, die manchmal als sauberer angesehen werden:

switch(true) {
    case cond1(): 
        statement1; break;
    case cond2():
        statement2; break;
    case cond3():
        statement3; break;
    // .. etc
}

Ternär mit richtigem Abstand kann auch eine gute Alternative sein:

cond1() ? statement1 :
cond2() ? statement2 :
cond3() ? statement3 : (null);

Sie könnten auch versuchen, ein Array mit einem Paar zu erstellen, das Bedingung und Funktion enthält, und es durchlaufen, bis die erste Bedingung erfüllt ist - was, wie ich sehe, Ewans erster Antwort entspricht.

Als Variante von @ Ewans Antwort könnten Sie eine Kette (anstelle einer "flachen Liste") von Bedingungen wie folgt erstellen :

abstract class Condition {
  private static final  Condition LAST = new Condition(){
     public void alertOrPropagate(DisplayInterface display){
        // do nothing;
     }
  }
  private Condition next = Last;

  public Condition setNext(Condition next){
    this.next = next;
    return this; // fluent API
  }

  public void alertOrPropagate(DisplayInterface display){
     if(isConditionMeet()){
         display.alert(getMessage());
     } else {
       next.alertOrPropagate(display);
     }
  }
  protected abstract boolean isConditionMeet();
  protected abstract String getMessage();  
}

Auf diese Weise können Sie Ihre Bedingungen in einer definierten Reihenfolge anwenden, und die Infrastruktur (die dargestellte abstrakte Klasse) überspringt die verbleibenden Prüfungen, nachdem die erste erfüllt wurde.

Hier ist es dem Ansatz der "flachen Liste" überlegen, bei dem Sie das "Überspringen" in der Schleife implementieren müssen, die die Bedingungen anwendet.

Sie richten einfach die Konditionskette ein:

Condition c1 = new Condition1().setNext(
  new Condition2().setNext(
   new Condition3()
 )
);

Und starten Sie die Auswertung mit einem einfachen Aufruf:

c1.alertOrPropagate(display);

Erstens ist der ursprüngliche Code IMO nicht schrecklich. Es ist ziemlich verständlich und nichts ist von Natur aus schlecht.

Wenn Sie es nicht mögen, bauen Sie auf @ Ewans Idee auf, eine Liste zu verwenden, aber sein etwas unnatürliches foreach breakMuster zu entfernen :

public class conditions
{
    private List<Condition> cList;
    private int position;

    public Condition Head
    {
        get { return cList[position];}
    }

    public bool Next()
    {
        return (position++ < cList.Count);
    }
}


while not conditions.head.check() {
  conditions.next()
}
conditions.head.alert()

Passen Sie dies nun in der Sprache Ihrer Wahl an, machen Sie jedes Element der Liste zu einem Objekt, einem Tupel, was auch immer, und Sie sind gut.

EDIT: Es sieht so aus, als wäre es nicht so klar, wie ich dachte. Lassen Sie mich das näher erläutern. conditionsist eine geordnete Liste irgendeiner Art; headwird das aktuelle Element untersucht - am Anfang ist es das erste Element der Liste, und jedes Mal, wenn next()es aufgerufen wird, wird es das folgende; check()und alert()sind das checkConditionX()und addAlert(X)vom OP.

Der Frage fehlen einige Einzelheiten. Wenn die Bedingungen sind:

• Änderungen vorbehalten oder
• wiederholt in anderen Teilen der Anwendung oder des Systems oder
• in bestimmten Fällen geändert (z. B. verschiedene Builds, Tests, Bereitstellungen)

oder wenn der inhalt addAlertkomplizierter ist, dann wäre eine möglicherweise bessere lösung in say c #:

//in some central spot
IEnumerable<Tuple<Func<bool>, int>> Conditions = new ... {
  Tuple.Create(CheckCondition1, 1),
  Tuple.Create(CheckCondition2, 2),
  ...
}

//at the original place
var matchingCondition = Conditions.Where(c=>c.Item1()).FirstOrDefault();
if(matchingCondition != null) 
  addAlert(matchingCondition.Item2)

Tupel sind in c # <8 nicht so schön, aber aus Gründen der Sicherheit ausgewählt.

Der Vorteil dieser Methode ist, dass die Struktur statisch typisiert ist, auch wenn keine der oben genannten Optionen zutrifft. Sie können nicht versehentlich vermasseln, indem Sie sagen, ein else.

Der beste Weg, um die Komplexität der Zyklomatik in Fällen zu reduzieren, in denen Sie viel zu tun haben, if->then statementsbesteht darin, ein Wörterbuch oder eine Liste (sprachabhängig) zu verwenden, um den Schlüsselwert (if-Anweisungswert oder einen Wert von) und dann ein Wert- / Funktionsergebnis zu speichern.

Zum Beispiel anstelle von (C #):

if (i > 10) { return "Two"; }
else if (i > 8) { return "Four" }
else if (i > 4) { return "Eight" }
return "Ten";  //etc etc say anything after 3 or 4 values

Ich kann einfach

var results = new Dictionary<int, string>
{
  { 10, "Two" },
  { 8, "Four"},
  { 4, "Eight"},
  { 0, "Ten"},
}

foreach(var key in results.Keys)
{
  if (i > results[key]) return results.Values[key];
}

Wenn Sie modernere Sprachen verwenden, können Sie mehr Logik als nur Werte speichern (c #). Dies sind eigentlich nur Inline-Funktionen, aber Sie können auch einfach auf andere Funktionen verweisen, wenn die Logik zu eng ist, um sie in die Linie zu setzen.

var results = new Dictionary<Func<int, bool>, Func<int, string>>
{
  { (i) => return i > 10; ,
    (i) => return i.ToString() },
  // etc
};

foreach(var key in results.Keys)
{ 
  if (key(i)) return results.Values[key](i);
}

Ich versuche, den sauberen Codevorschlägen von Onkel Bob zu folgen und Methoden kurz zu halten.

Ich bin jedoch nicht in der Lage, diese Logik zu verkürzen:

if (checkCondition()) {addAlert(1);}
else if (checkCondition2()) {addAlert(2);}
else if (checkCondition3()) {addAlert(3);}
else if (checkCondition4()) {addAlert(4);}

Ihr Code ist bereits zu kurz, aber die Logik selbst sollte nicht geändert werden. Auf den ersten Blick sieht es so aus, als würden Sie sich mit vier Anrufen wiederholen checkCondition(), und es ist nur offensichtlich, dass jeder nach erneutem sorgfältigen Lesen des Codes anders ist. Sie sollten korrekte Formatierungs- und Funktionsnamen hinzufügen, z.

if (is_an_apple()) {
  addAlert(1);
}
else if (is_a_banana()) {
  addAlert(2);
}
else if (is_a_cat()) {
  addAlert(3);
}
else if (is_a_dog()) {
  addAlert(4);
}

Ihr Code sollte vor allem lesbar sein. Ich glaube, nachdem er mehrere Bücher von Onkel Bob gelesen hat, ist dies die Botschaft, die er konsequent vermitteln will.

Angenommen, alle Funktionen sind in derselben Komponente implementiert, könnten Sie dafür sorgen, dass die Funktionen einen bestimmten Status beibehalten, um die mehreren Zweige im Ablauf zu entfernen.

EG: checkCondition1()würde werden evaluateCondition1(), auf dem es prüfen würde, ob vorherige Bedingung erfüllt wurden; In diesem Fall wird ein Wert zwischengespeichert, der von abgerufen werden soll getConditionNumber().

checkCondition2()würde werden evaluateCondition2(), auf dem es prüfen würde, ob die bisherigen Bedingungen erfüllt waren. Wenn die vorherige Bedingung nicht erfüllt wurde, wird nach Bedingungsszenario 2 gesucht und ein Wert zwischengespeichert, von dem abgerufen werden soll getConditionNumber(). Und so weiter.

clearConditions();
evaluateCondition1();
evaluateCondition2();
evaluateCondition3();
evaluateCondition4();
if (anyCondition()) { addAlert(getConditionNumber()); }

BEARBEITEN:

Hier ist, wie die Prüfung auf teure Bedingungen implementiert werden müsste, damit dieser Ansatz funktioniert.

bool evaluateCondition34() {
    if (!anyCondition() && A && B && C) {
        conditionNumber = 5693;
        return true;
    }
    return false;
}

...

bool evaluateCondition76() {
    if (!anyCondition() && !B && C && D) {
        conditionNumber = 7658;
        return true;
    }
    return false;
}

Wenn Sie zu viele teure Überprüfungen durchführen müssen und die in diesem Code enthaltenen Informationen vertraulich bleiben, können Sie diese auf diese Weise beibehalten und die Reihenfolge der Überprüfungen bei Bedarf ändern.

clearConditions();
evaluateCondition10();
evaluateCondition9();
evaluateCondition8();
evaluateCondition7();
...
evaluateCondition34();
...
evaluateCondition76();

if (anyCondition()) { addAlert(getConditionNumber()); }

Diese Antwort bietet nur einen alternativen Vorschlag von den anderen Antworten und wird wahrscheinlich nicht besser als der ursprüngliche Code sein, wenn wir nur 4 Codezeilen berücksichtigen. Dies ist zwar kein schrecklicher Ansatz (und erschwert auch nicht die Wartung, wie andere bereits gesagt haben) in Anbetracht des erwähnten Szenarios (zu viele Überprüfungen, nur die Hauptfunktion wird als öffentlich angezeigt, alle Funktionen sind Implementierungsdetails derselben Klasse).

Mehr als zwei "else" -Klauseln zwingen den Leser des Codes, die gesamte Kette zu durchlaufen, um den gewünschten zu finden. Verwenden Sie eine Methode wie: void AlertUponCondition (Bedingungsbedingung) {switch (Bedingung) {case Condition.Con1: ... break; case Condition.Con2: ... break; etc ...} Wobei "Bedingung" eine richtige Aufzählung ist. Geben Sie bei Bedarf einen Bool oder einen Wert zurück. Nennen Sie es wie folgt: AlertOnCondition (GetCondition ());

Einfacher geht es wirklich nicht und schneller als die If-else-Kette, wenn Sie einige Fälle überschreiten.

Ich kann nicht für Ihre spezielle Situation sprechen, da der Code nicht spezifisch ist, aber ...

Code wie dieser ist oft ein Geruch für ein fehlendes OO-Modell. Sie haben wirklich vier Arten von Dingen, von denen jede ihrem eigenen Alarmertyp zugeordnet ist. Anstatt jedoch diese Entitäten zu erkennen und für jede Instanz eine Klasse zu erstellen, behandeln Sie sie als eine Sache und versuchen, dies zu einem späteren Zeitpunkt nachzuholen Sie müssen wissen, womit Sie es zu tun haben, um fortzufahren.

Polymorphismus könnte Ihnen besser gefallen haben.

Seien Sie misstrauisch gegenüber Code mit langen Methoden, die lange oder komplexe If-Then-Konstrukte enthalten. Oft möchten Sie dort einen Klassenbaum mit einigen virtuellen Methoden.