Hat es jemals Sinn für einen Refaktor, mit einem höheren LOC zu enden? [geschlossen]

Gibt es Fälle, in denen ausführlicherer Code (wie in logischeren Anweisungen) sauberer ist als präziserer Code?

Um das zu beantworten, nehmen wir ein reales Beispiel, das mir passiert ist. In C #, einer von mir verwalteten Bibliothek, hatte ich den folgenden Code:

TResult IConsFuncMatcher<T, TResult>.Result() =>
    TryCons(_enumerator) is var simpleMatchData && !simpleMatchData.head.HasValue
        ? _emptyValue.supplied
            ? _emptyValue.value
            : throw new NoMatchException("No empty clause supplied");
        : _recursiveConsTests.Any() 
            ? CalculateRecursiveResult() 
            : CalculateSimpleResult(simpleMatchData);

Bei der Diskussion mit Gleichaltrigen war man sich einig, dass die verschachtelten ternären Ausdrücke in Verbindung mit der "geschickten" Verwendung von is varknappem, aber schwer lesbarem Code resultierten.

Also habe ich es überarbeitet:

TResult IConsFuncMatcher<T, TResult>.Result()
{
    var simpleMatchData = TryCons(_enumerator);

    if (!simpleMatchData.head.HasValue)
    {
        return _emptyValue.supplied
            ? _emptyValue.value
            : throw new NoMatchException("No empty clause supplied");
    }

    return _recursiveConsTests.Any() 
        ? CalculateRecursiveResult() 
        : CalculateSimpleResult(simpleMatchData);
}

Die ursprüngliche Version enthielt nur einen zusammengesetzten Ausdruck mit einem Implizit return. Die neue Version enthält jetzt eine explizite Variablendeklaration, eine ifAnweisung und zwei explizite returns. Es enthält mehr Anweisungen und mehr Codezeilen. Alle, die ich konsultierte, hielten es jedoch für einfacher zu lesen und zu argumentieren, die Schlüsselaspekte von "sauberem Code" sind.

Die Antwort auf Ihre Frage lautet also nachdrücklich "Ja", ausführlicher kann sauberer sein als prägnanter Code und ist daher ein gültiges Refactoring.

1. Fehlende Korrelation zwischen LOC und Codequalität.

Ziel des Refactorings ist es, die Qualität eines Codeteils zu verbessern.

LOC ist eine sehr grundlegende Metrik, die manchmal mit der Qualität eines Codeteils korreliert. Beispielsweise ist es wahrscheinlich, dass bei einer Methode mit einigen Tausend LOC Qualitätsprobleme auftreten. Es ist jedoch zu beachten, dass LOC nicht die einzige Metrik ist und in vielen Fällen die Korrelation mit der Qualität fehlt. Beispielsweise ist eine 4-LOC-Methode nicht unbedingt besser lesbar oder besser wartbar als eine 6-LOC-Methode.

2. Einige Refactoring-Techniken bestehen aus dem Hinzufügen von LOCs.

Wenn Sie eine Liste von Refactoring-Techniken verwenden , können Sie leicht diejenigen erkennen, die darin bestehen, absichtlich LOCs hinzuzufügen . Beispiele:

• Ersetzen Sie Magic Number durch Symbolic Constant .
• Variable extrahieren .

Beide sind sehr nützliche Refactoring-Techniken, und ihre Auswirkung auf das LOC ist völlig irrelevant, wenn überlegt wird, ob sie verwendet werden sollen oder nicht.

Vermeiden Sie die Verwendung von LOC.

LOC ist eine gefährliche Metrik. Es ist sehr leicht zu messen und sehr schwer richtig zu interpretieren.

Bevor Sie nicht mit den Techniken zur Messung der Codequalität vertraut sind, sollten Sie zunächst darauf verzichten, den LOC zu messen. Meistens erhalten Sie nichts Relevantes, und es gibt Fälle, in denen Sie in die Irre geführt werden, die Qualität Ihres Codes zu verringern.

Wenn Sie das ultimative Ergebnis sehen möchten, indem Sie nur die Byteanzahl oder die LoC-Anzahl Ihres Quellcodes minimieren, sehen Sie sich die Einsendungen auf der Stack Exchange Code Golf-Website an .

Wenn Ihr Quellcode auf diese Weise reduziert wird, werden Sie bald ein unhaltbares Durcheinander haben. Selbst wenn Sie derjenige sind, der einen solchen Code geschrieben hat und ihn zu diesem Zeitpunkt vollständig verstanden hat, wie effizient werden Sie sein, wenn Sie in sechs Monaten wieder darauf zugreifen? Es gibt keine Beweise dafür, dass solch minimaler Code tatsächlich auch schneller ausgeführt wird.

Code sollte so geschrieben sein, dass jedes Mitglied Ihres Teams ihn sehen und sofort verstehen kann, was er tut.

Ja, Refactoring kann definitiv zu mehr Codezeilen führen.

Der häufigste IMO-Fall ist, wenn Sie Code verwenden, der nicht generisch ist, und Sie ihn generischer / flexibler gestalten . Durch die einfache Generierung von Code werden die Codezeilen erheblich vergrößert (manchmal um den Faktor zwei oder mehr).

Wenn Sie davon ausgehen, dass der neu generierte Code von anderen (anstatt nur als interne Softwarekomponente) als Bibliothek verwendet wird, fügen Sie in der Regel unauffälligen Code und In-Code-Dokumentations-Markup hinzu, wodurch die Codezeilen erneut erhöht werden.

Zum Beispiel ist hier ein sehr häufiges Szenario, das für jeden Softwareentwickler auftritt:

• Ihr Produkt benötigt dringend eine neue Funktion mit hoher Priorität oder eine Fehlerbehebung oder -verbesserung in zwei Wochen (oder in einem für Ihre Projektgröße / Unternehmensgröße / usw. als dringend erachteten Zeitraum).
• Sie arbeiten hart und liefern XYZ pünktlich und es funktioniert. Herzliche Glückwünsche! Gut gemacht!
• Während Sie XYZ entwickelten, unterstützte Ihr vorhandenes Code-Design / Ihre vorhandene Code-Implementierung XYZ nicht wirklich, aber Sie konnten XYZ in die Codebasis einbinden
• Das Problem ist, dass das Shim hässlich ist und einen schrecklichen Code-Geruch hat, weil Sie einige knifflige / clevere / hässliche / schlechte Übungen gemacht haben, die aber irgendwie funktionieren
• Wenn Sie später Zeit finden, überarbeiten Sie den Code, der möglicherweise viele Klassen ändert, oder fügen eine neue Klassenebene hinzu, und Ihre neue Lösung ist "richtig gemacht" und hat keinen schlechten Codegeruch mehr "Richtig" nimmt jetzt viel mehr Codezeilen in Anspruch.

Einige konkrete Beispiele, die mir auf den ersten Blick einfallen:

• Für eine Befehlszeilenschnittstelle könnten Sie 5000 Zeilen if / else-if-Code haben, oder Sie könnten Rückrufe verwenden ... jeder Rückruf wäre viel kleiner und einfacher zu lesen / testen / verifizieren / debuggen / etc, aber wenn Sie Zeilen zählen Code Die hässlichen 5000 Zeilen von if / else-if-Code wären wahrscheinlich kleiner
• Für ein Stück Code, das N Verarbeitungsmethoden unterstützt , könnten Sie erneut if / else-Anweisungen verwenden, die am hässlichsten aussehen würden ...
  • oder Sie könnten auf Callbacks umsteigen, die schöner / besser wären, aber Callbacks benötigen mehr Codezeilen (trotzdem Kompilierzeit)
  • Oder Sie können weiter abstrahieren und Plugins erstellen, die zur Laufzeit geändert werden können. Plugins sind nett, weil Sie das Hauptprodukt nicht für jedes neue Plugin oder jede Änderung an einem vorhandenen Plugin neu kompilieren müssen. und Sie können die API veröffentlichen, damit andere das Produkt erweitern können. ABER wieder verwendet ein Plugin-Ansatz mehr Codezeilen.
• Für eine GUI erstellen Sie ein großartiges neues Widget
  • Sie oder ein Mitarbeiter stellen fest, dass das neue Widget für XYZ und ABC großartig wäre, aber im Moment ist das Widget eng integriert, um nur für XYZ zu funktionieren
  • Sie können das Widget so umgestalten, dass es für beide Anwendungen funktioniert. Jetzt wird die Gesamtzahl der Codezeilen erhöht