Umgang mit lockiger Zahnspangensuppe

Ich habe jahrelang sowohl in C # als auch in VB.NET programmiert, aber hauptsächlich in VB. Ich mache eine Karriereverlagerung in Richtung C # und insgesamt mag ich C # besser.

Ein Problem, das ich jedoch habe, ist die geschweifte Zahnspangensuppe. In VB hat jedes Strukturschlüsselwort ein übereinstimmendes Schlüsselwort zum Schließen, zum Beispiel:

Namespace ...
    Class ...
        Function ...
            For ...
                Using ...
                    If ...
                        ...
                    End If
                    If ...
                        ...
                    End If
                End Using
            Next
        End Function
    End Class
End Namespace

Der gleiche in C # geschriebene Code ist sehr schwer zu lesen:

namespace ... {
    class ... {
        function ... {
            for ... {
                using ... {
                    if ... {
                        ...
                    }
                    if ... {
                        ...
                    }
                }
            }
            // wait... what level is this?
        }
    }
}

Da ich so an VB gewöhnt bin, frage ich mich, ob es eine Technik gibt, die von Programmierern im C-Stil verwendet wird, um die Lesbarkeit zu verbessern und sicherzustellen, dass Ihr Code im richtigen "Block" landet. Das obige Beispiel ist relativ einfach zu lesen, aber manchmal habe ich am Ende eines Codeteils 8 oder mehr Ebenen geschweifter Klammern, sodass ich mehrere Seiten nach oben scrollen muss, um herauszufinden, welche Klammer den Block beendet, an dem ich interessiert bin im.

Setzen Sie Ihre beginnende geschweifte Klammer in den gleichen "Rang" wie Ihre endende:

namespace ... 
{
    class ... 
    {
        function ... 
        {
            for ... 
            {
                using ... 
                {
                    if ... 
                    {
                        ...
                    }
                    if ... 
                    {
                        ...
                    }
                }
            }
            // It's the `function` level!
        }
    }
}

• Abhängig von Ihrer IDE: Setzen Sie den Cursor auf die Klammer zum Öffnen / Schließen, um sowohl diese als auch die entsprechende Klammer hervorzuheben.
• Reduzieren Sie den Block und es zeigt Ihnen, wo er geöffnet / geschlossen wird.
• Schreiben Sie kleinere Codeblöcke. Ernsthaft. Probieren Sie es aus Clean Codeund stoßen Sie nie wieder auf dieses Problem (und haben Sie mehr lesbaren / wartbaren Code).

Ein Hinweis, die folgende ist eine gültige c # -Syntax, die Ihrer speziellen Situation helfen könnte:

using (var type = new MyDisposable1())
using (var type2 = new MyDisposable2())
{
    /* do what you will with type2 and type2 */
}

Eine übliche Konvention besteht darin, nach der schließenden Klammer einen Kommentar hinzuzufügen, um die Struktur anzugeben, die geschlossen wird:

if {
   ...
} // end if

while (condition) {
   ...
} // end while

usw. Ich habe mich nie auf diese Konvention erwärmt, aber einige Leute finden sie hilfreich.

Wenn es schwierig wird, Zahnspangen in einem beliebigen Stil zu finden, bedeutet dies im Allgemeinen wahrscheinlich, dass die Methode zu lang ist und neu berücksichtigt werden sollte.

Ich denke, Sie müssen es mit den Zahnspangen aushalten. Irgendwann werden sie für Sie zur zweiten Natur und Sie werden sich fragen, wie Sie jemals ohne sie gelebt haben.

Stellen Sie jedoch sicher, dass sie entsprechend eingerückt sind und dass einige Abstandskonventionen eingehalten werden (egal welche).

Ich entferne zwei Verschachtelungsebenen, indem ich den Namespace und die Klassenbereiche horizontal reduziere. Beachten Sie, dass die Methoden bündig mit dem linken Bildschirmrand abschließen. Ich sehe keinen Sinn darin, in jeder Datei zwei Einrückungsstufen zu verlieren.

Danach ist es selten, dass Sie jemals mehr als 4 Ebenen tief verschachtelt haben.

namespace FooNameSpace {
class Foo {

public void bar()
{
    while(true)
    {
        while(true)
        {
            break;
        }
    }
}

public void fooBar()
{
    foreach(var item in FooList)
    {
        foreach(var b in item.Bars)
        {
            if(b.IsReady)
            {
                bar();
            }
            bar();
        }
        bar();
    }
}

}}//end class, namespace

Ich habe kürzlich beschlossen, zwei Regeln für Flusskontrollkonstrukte zu formalisieren, die im Grunde so aussehen:

• Sie sollten nur die erforderlichen Code-Flow-Konstrukte haben
• Sie sollten die Code-Flow-Konstrukte so klein wie möglich machen

Aus genau den Gründen, die Sie erwähnt haben und die Sie genau kennen, halte ich dies für gute Regeln. Es gibt ein paar einfache Techniken, mit denen Sie sie erreichen können:

• Beenden Sie den Bereich so bald wie möglich (dies umfasst sowohl den Umfang der Schleifen als auch die Funktionen).
• Achten Sie auf andere Faktoren, die durch Beenden der Funktion aus dem vorhergehenden if gemildert werden könnten, und wenden Sie die erwähnte Technik zum Beenden des Bereichs an
• Kehren Sie Ihre bedingten Prüfungen um, wenn der Code innerhalb eines if größer ist als der außerhalb
• Faktorcode innerhalb einer Schleife wird zu einer anderen Methode ausgegeben, wenn die Größe der Schleife zunimmt, um den Rest der Methode zu verdecken
• Achten Sie auf Bereiche, die nur einen anderen Bereich enthalten, z. B. eine Funktion, deren gesamter Bereich von einem if mit nichts außerhalb des if gefüllt ist

Ich habe hier Beispiele aufgeführt, wie das Nichtbefolgen dieser Anweisungen dazu führen kann, dass Sie das tun, was Sie gesagt haben, und Code in den falschen Codeblock einfügen. Dies ist schlecht und eine einfache Ursache für das Auftreten von Fehlern während der Wartung.

Dies ist leider eine der ältesten Ursachen für Kriegsführung im Computer. Von beiden Seiten können vernünftige Argumente vorgebracht werden (bessere vertikale Immobilienökonomie im Vergleich zu einer einfacheren Möglichkeit, die öffnende Klammer visuell mit der schließenden Klammer abzugleichen), aber in Wirklichkeit wird ein einfacher Quellcode-Formatierer alles für Sie lösen. In MS Visual C # ist eine integriert, die gut funktioniert.

Seien Sie jedoch gewarnt, dass Sie, wenn Sie als Teil eines Teams arbeiten, die von diesem Team verwendeten Konventionen einhalten müssen. Es lohnt sich daher, sich mit beiden Stilen vertraut zu machen und nicht religiös zu werden.

Konzentrieren Sie sich also auf jeden Fall auf den Stil, der Ihnen das Lernen erleichtert, aber behalten Sie den anderen im Auge, während Sie gerade dabei sind, und Sie werden es gut machen.

Verwenden Sie Resharper, um Möglichkeiten zur Reduzierung der Verschachtelung zu empfehlen. Lesen Sie auch Bob Martins Buch Clean Code , in dem betont wird, dass eine Funktion nur eines tun sollte und daher jede Funktion nur ein halbes Dutzend Zeilen lang sein sollte, damit Sie sich nicht um so viele Verschachtelungsebenen kümmern müssen.

Es gibt ein Add-On zum Editor, das Ihnen bei folgenden Aufgaben helfen kann: C # Outline .

Das Add-On erweitert den VS20xx-Editor für C # um Funktionen zum Reduzieren, Erweitern und Hervorheben verschachtelter Codeblöcke. Diese Funktionen ermöglichen das einfachere Bearbeiten und Lesen verschachtelter Inhalte von Codeblöcken wie if, while usw.

Wenn Sie Ihren Code in Visual Studio schreiben, gibt es auch ein Plugin, das Ihnen vertikale Punkte zwischen dem Anfang und dem Ende jeder von Ihnen erstellten Struktur anzeigt.

Aber insgesamt denke ich, dass es nur einige Zeit dauern wird, bis Sie an die "Curly-Braces-Suppe" gewöhnt sind. (Übrigens mag ich diesen Ausdruck wirklich. Klingt ein bisschen wie ein Episodenname für die Urknalltheorie)

Einzug sagt Ihnen, wo Sie sich befinden, in beiden Syntaxstilen. Wenn Sie entweder ein VB-Programm oder ein C # -Programm in eine einzelne Zeile schreiben, können Sie in der verschachtelten Syntax bald nicht mehr erkennen, wo Sie sich befinden. Die Maschine analysiert die Blockendphrasen oder geschweiften Klammern, aber Menschen brauchen Einrückungen.

Blockendphrasen stammen aus einer Ära von Lochkarten und Papierbändern, als die Programmierung viel weniger interaktiv und visuell war. Oder wirklich überhaupt nicht interaktiv. Es war schwierig, Programme einzugeben, und deshalb brauchten Programmierer Compiler, die sich mit Syntaxanalyse und Fehlerbehebung auskennen.

In dieser vergangenen Ära bestand der Zyklus zum Bearbeiten, Kompilieren und Ausführen möglicherweise darin, Lochkarten mit einem Kartenstempel vorzubereiten und sich dann an ein Fenster für die Auftragsübermittlung zu stellen, in dem ein Angestellter die Lochkarten nahm und sie an die Maschine übermittelte. Später sammelte der Programmierer die Ausgabe (auf Papier gedruckt) in einem anderen Fenster. Wenn das Programm Fehler hätte, würde die Ausgabe nur aus der Compiler-Diagnose bestehen. Wenn die Bearbeitungszeiten lang sind, sind die zusätzlichen Kosten für die Eingabe end ifanstelle von nur )gerechtfertigt, wenn dies zur Verbesserung der Diagnosequalität beiträgt, da der Programmierer so viele Fehler wie möglich in einer einzigen Iteration korrigieren muss, um die Anzahl der Zeitverschwendung zu verringern Iterationen durch das Jobübermittlungsfenster.

Wenn eine schließende geschweifte Klammer fehlt, ist es schwer zu sagen, welche offene Klammer die nicht geschlossene ist. (Der Compiler muss möglicherweise Einrückungen analysieren, um eine fundierte Vermutung anzustellen.) Wenn Sie eine schließende Klammer innerhalb einer Funktion löschen, sieht es so aus, als ob der gesamte Rest der Datei Teil dieser Funktion ist, was zu einer Reihe nicht hilfreicher Fehlermeldungen führt. Wenn Sie hingegen über eine end functionSyntax verfügen , kann der Compiler ableiten, wo die fehlerhafte Funktion endet, die nachfolgenden Funktionen ordnungsgemäß wiederherstellen und analysieren, sodass Sie gegebenenfalls zusätzliche Diagnosen erhalten, die von Bedeutung sind.

Wenn Sie in einem Code-fähigen Texteditor arbeiten, der Ihren Code automatisch einrückt und einfärbt, gelten auf einem hochauflösenden Bildschirm, auf dem Sie 60 oder mehr Zeilen sehen, die Argumente für diese Art von ungeschickten Sprachen nicht mehr. Sie können Programme schrittweise so schnell bearbeiten und neu erstellen, dass Sie jeweils nur einen Fehler behandeln können. Darüber hinaus können Sie das Auftreten solcher Verschachtelungsfehler reduzieren, indem Sie große Teile des Programms gleichzeitig auf dem Bildschirm anzeigen und die richtige Einrückung beibehalten. Und ein guter Programmier-Texteditor kennzeichnet während der Eingabe sogar einige Arten von Syntaxfehlern. Darüber hinaus gibt es faltbare Editoren, die die Blöcke eines Programms basierend auf seiner Syntax reduzieren und so eine "umrissartige" Ansicht seiner Struktur geben.

Lisp verwendete von Anfang an Klammern, und vielleicht, nicht zufällig, leisteten Lisp-Hacker Pionierarbeit beim Programmieren als interaktives Erlebnis, indem sie Systeme erstellten, die Programme in kleinen Blöcken (Ausdrücken) akzeptierten.

Tatsächlich benötigen Sie überhaupt keine Endsymbole, wie die Python-Sprache zeigt. Die identation kann nur sein , die Struktur. Menschen verwenden bereits Einrückungen, um die Struktur des Codes selbst in Sprachen zu erfassen, in denen die Maschine auf Endsymbole oder -phrasen angewiesen ist.

Wenn Sie eine IDE verwenden, drücken Sie einfach Crtl+ k+ Dund die IDE erledigt den Rest der Arbeit.