Faire face à la soupe aux accolades

J'ai programmé à la fois en C # et en VB.NET pendant des années, mais principalement en VB. Je fais un changement de carrière vers C # et, dans l'ensemble, j'aime mieux C #.

Un problème que j'ai, cependant, est la soupe aux accolades. Dans VB, chaque mot-clé de structure a un mot-clé de fermeture correspondant, par exemple:

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

Le même code écrit en C # se révèle très difficile à lire:

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

Étant tellement habitué à VB, je me demande s'il existe une technique employée par les programmeurs de style c pour améliorer la lisibilité et garantir que votre code se retrouve dans le "bloc" correct. L'exemple ci-dessus est relativement facile à lire, mais parfois à la fin d'un morceau de code, j'ai 8 niveaux ou plus d'accolades, ce qui m'oblige à faire défiler plusieurs pages pour déterminer quelle accolade termine le bloc qui m'intéresse dans.

Mettez votre accolade bouclée de départ dans le même "rang" que votre accolade de fin, comme ceci:

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

• En fonction de votre IDE: placez votre curseur sur l'accolade ouverte / fermée et il mettra en surbrillance à la fois cela et l'accolade correspondante.
• Réduisez le bloc et il vous montre où il s'ouvre / se ferme.
• Écrivez des blocs de code plus petits. Sérieusement. Vérifiez Clean Codeet ne rencontrez plus jamais ce problème (et ayez un code plus lisible / maintenable).

Une remarque, ce qui suit est une syntaxe c # valide qui pourrait aider votre situation particulière:

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

Une convention courante consiste à ajouter un commentaire après l'accolade fermante pour indiquer la structure qu'elle ferme:

if {
   ...
} // end if

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

etc. Je ne me suis jamais réchauffé à cette convention moi-même, mais certaines personnes la trouvent utile.

En général, quand il devient difficile de faire correspondre les accolades dans n'importe quel style - cela signifie probablement que la méthode est trop longue et doit être refactorisée.

Je pense que vous devez endurer les accolades. Finalement, ils deviendront une seconde nature pour vous et vous vous demanderez comment vous avez pu vivre sans eux.

Assurez-vous cependant qu'ils sont en retrait de manière appropriée et que certaines conventions d'espacement sont respectées (peu importe laquelle).

Je supprime 2 niveaux d'imbrication en réduisant horizontalement l'espace de noms et les étendues de classe. Notez que les méthodes affleurent le bord gauche de l'écran. Je ne vois pas l'intérêt de perdre 2 niveaux d'indentation dans chaque fichier.

Après cela, il est rare que vous ayez jamais niché à plus de 4 niveaux.

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

J'ai récemment décidé d'essayer de formaliser deux règles sur les constructions de contrôle de flux qui vont essentiellement comme ceci:

• Vous ne devriez avoir que des constructions de flux de code nécessaires
• Vous devez rendre les constructions de flux de code aussi petites que possible

Pour exactement les raisons que vous avez mentionnées et que vous connaissez clairement, je pense que ce sont d'excellentes règles à suivre. Il existe quelques techniques simples que vous pouvez utiliser pour les accomplir:

• Quittez la portée dès que vous le pouvez (cela inclut la portée des boucles ainsi que les fonctions)
• Surveillez les autres qui pourraient être atténués en quittant la fonction du précédent si et appliquez la technique de sortie de la portée comme je l'ai mentionné
• Inversez vos vérifications conditionnelles lorsque le code à l'intérieur d'un if est supérieur à celui à l'extérieur
• Factoriser le code à l'intérieur d'une boucle vers une autre méthode lorsque la taille de la boucle augmente pour masquer le reste de la méthode
• Surveillez les étendues qui ne contiennent qu'une autre étendue, par exemple une fonction dont toute l'étendue est remplie par un if sans rien en dehors du if

J'ai détaillé ici des exemples de la façon dont ne pas les suivre peut vous obliger à faire comme vous l'avez dit et à mettre du code dans le mauvais bloc de code, ce qui est mauvais et une cause facile de bogues se reproduisant pendant la maintenance.

C'est malheureusement l'une des plus anciennes causes de guerre informatique. Des arguments raisonnables peuvent être avancés des deux côtés (meilleure économie immobilière verticale par rapport à une capacité plus facile de faire correspondre visuellement l'accolade ouvrante à l'accolade fermante), mais en réalité, un simple formateur de code source résoudra tout pour vous. MS Visual C # en a un intégré qui fonctionne bien.

Soyez averti cependant que si vous travaillez au sein d'une équipe, vous devrez vous conformer aux conventions utilisées par cette équipe, il est donc avantageux de se familiariser avec les deux styles et de s'abstenir de devenir religieux par rapport aux styles d'accolades.

Donc, pendant que vous apprenez, concentrez-vous sur le style qui vous facilite l'apprentissage, mais gardez un œil sur l'autre pendant que vous y êtes et vous irez bien.

Utilisez Resharper, qui vous recommandera des moyens de réduire l'imbrication. Lisez également le livre Clean Code de Bob Martin , qui souligne qu'une fonction ne doit faire qu'une seule chose, et donc que chaque fonction ne doit comporter qu'une demi-douzaine de lignes, de sorte que vous n'aurez pas autant de niveaux d'imbrication à vous soucier.

Il existe un module complémentaire à l'éditeur qui peut vous aider à: C # Outline .

Le module complémentaire étend l'éditeur VS20xx pour C # en ajoutant des fonctionnalités pour réduire, développer et mettre en évidence des blocs de code imbriqués. Ces fonctionnalités permettent une édition et une lecture plus faciles du contenu imbriqué des blocs de code tels que if, while, etc.

Si vous écrivez votre code dans Visual Studio, il existe également un plugin qui vous montre des points verticaux entre le début et la fin de chaque structure que vous construisez.

Mais dans l'ensemble, je pense que cela prendra juste un peu de temps jusqu'à ce que vous soyez habitué à la "Curly-Braces-Soup". (Btw, j'aime vraiment cette expression. Cela ressemble un peu à un nom d'épisode pour The Big Bang Theory)

L'indentation vous indique où vous êtes, dans les deux styles de syntaxe. Si vous écrivez un programme VB ou un programme C # sur une seule ligne, vous ne pourrez bientôt pas dire où vous vous trouvez dans la syntaxe imbriquée. La machine analyse les phrases de fin de bloc ou les accolades, mais les humains ont besoin d'indentation.

Les phrases de fin de bloc viennent d'une époque de cartes perforées et de bandes de papier, lorsque la programmation était beaucoup moins interactive et visuelle. Ou, vraiment, pas du tout interactif. Il était difficile d'entrer des programmes, et les programmeurs avaient donc besoin de compilateurs pour être très intelligents sur l'analyse syntaxique et la récupération d'erreurs.

À cette époque révolue, le cycle d'édition-compilation-exécution aurait pu impliquer la préparation de cartes perforées avec un perforateur de cartes, puis l'alignement sur une fenêtre de soumission de travail où un commis a pris les cartes perforées et les a soumises à la machine. Plus tard, le programmeur collecterait la sortie (imprimée sur papier) d'une autre fenêtre. Si le programme avait des erreurs, la sortie se composerait uniquement des diagnostics du compilateur. Lorsque les délais d'exécution sont longs, le coût supplémentaire de la frappeend if au lieu de simplement )est justifié s'il contribue à améliorer la qualité des diagnostics, car le programmeur doit corriger autant d'erreurs que possible en une seule itération pour réduire le nombre de pertes de temps itérations via la fenêtre de soumission des travaux.

Lorsqu'une accolade fermante est manquante, il est difficile de dire quelle accolade ouverte est celle qui n'est pas fermée. (Le compilateur peut devoir analyser l'indentation pour faire une supposition éclairée.) Si vous supprimez une accolade fermante à l'intérieur d'une fonction, il semble que le reste du fichier fasse partie de cette fonction, ce qui entraîne une multitude de messages d'erreur inutiles. Alors que si vous avez unend function syntaxe, le compilateur peut déduire où se termine la fonction erronée, récupérer et analyser correctement les fonctions suivantes, vous donnant des diagnostics supplémentaires, le cas échéant, qui sont significatifs.

Lorsque vous travaillez dans un éditeur de texte sensible au code qui indente et colorise automatiquement votre code, sur un écran haute résolution où vous pouvez voir soixante lignes ou plus, les arguments pour ces types de langages maladroits ne s'appliquent plus. Vous pouvez éditer et reconstruire de manière incrémentielle des programmes si rapidement que vous ne pouvez traiter qu'une seule erreur à la fois. De plus, en voyant simultanément de grandes sections du programme à l'écran et en conservant une indentation appropriée, vous pouvez réduire l'apparition de ces types d'erreurs d'imbrication en premier lieu. Et un bon éditeur de texte de programmation signalera même certains types d'erreurs de syntaxe lors de la frappe. De plus, il existe des éditeurs pliants qui réduiront les blocs d'un programme en fonction de sa syntaxe, donnant une vue "schématique" de sa structure.

Lisp a utilisé des parenthèses depuis le début et peut-être, pas par coïncidence, les pirates de Lisp ont lancé la programmation comme une expérience interactive en construisant des systèmes qui acceptaient les programmes en petits morceaux (expressions).

En fait, vous n'avez pas du tout besoin de symboles de fin, comme l'illustre le langage Python. L'identification ne peut être que la structure. Les humains utilisent déjà l'indentation pour masquer la structure du code, même dans les langues où la machine s'appuie sur des symboles ou des phrases de fin.

Si vous utilisez un IDE, appuyez simplement sur Crtl+ k+ Det l'IDE fera le reste du travail.