web-dev-qa-db-fra.com

Refactoring dans de nombreux procédés - est-ce considéré comme propre ou non?

Donc, j'ai regardé alors que mon collègue se plaint un peu sur un projet qu'il a hérité de quelqu'un qui est, dirons-nous, n'est pas très expérimenté comme programmeur (stagiaire laissé à ses propres appareils sur un projet).

À un moment donné, il y avait du code dupliqué, environ 7 à 8 lignes de code dupliqué de code (SO 14-16 lignes total) dans une méthode de Dire 70-80 lignes de code. Nous discutions du code et il a repéré un moyen de refroidir cela pour enlever la duplication en modifiant un peu la structure.

J'ai dit génial, puis nous devrions également déplacer le code sur une méthode distincte afin que la grande méthode soit un peu plus lisible.

Il a dit "Non, je ne créerais jamais une méthode pour seulement 7-8 lignes de code".

Questions de performance de côté, que sont votre saisie à ce sujet? Vous penchez-vous contre l'utilisation de plus de méthodes (qui dans le code de pads C # avec environ 3 lignes) ou des méthodes plus grandes, lorsque ce code particulier ne sera probablement pas utilisé nulle part ailleurs? C'est donc purement une question de lisibilité, pas une réutilisation de code.

À votre santé :)

refactoringreadabilitymethods
46
Max

Le LOC dans une méthode est une mesure complètement inutile. Les choses importantes sont la séparation des préoccupations et la duplication de code.

Une méthode ne devrait faire qu'une seule chose et qu'une chose doit être exprimée en son nom. D'autres choses doivent être laissées à d'autres méthodes.

Les problèmes découlant de la duplication de code ne peuvent être surestimés (en d'autres termes, ils sont toujours plus gros que vous ne le pensez). Et cela seul justifiera même des méthodes avec 1 ligne de code.

D'autre part, une méthode qui remplit une grosse forme avec des détails d'un gros objet de données peut facilement avoir 50 lignes de code ou plus, mais sans une seule déclaration conditionnelle. Pourquoi voudriez-vous rompre cela en morceaux plus petits s'il n'y a pas d'exigence fonctionnelle (ou de la duplication de code)?

84
wolfgangsz

Les méthodes plus courtes sont beaucoup plus lisibles - moins de choses à garder à l'esprit pour les comprendre . Les avocats les plus vocaux du code de nettoyage diraient probablement que presque tout Les méthodes doivent être shortter de 8 lignes. Et à peu près, chaque développeur qui est intéressé par le sujet conviendra que 70-80 lignes de code dans une méthode sont trop nombreuses et que cela devrait être brisé.

25
Michael Borgwardt

Tout est question de séparation des préoccupations. La méthode devrait répondre à une question ou faire une décision. Et c'est tout. Ainsi, avoir les méthodes de 100 lignes de code signifie que ces méthodes sont tout simplement trop. 7-8 méthodes locales sont absolument géniales. L'autre question est - où allez-vous mettre toutes ces méthodes? Avoir 20 méthodes courtes dans une seule classe est probablement un sujet de préoccupation. En avoir 30 d'entre eux, je crois, la bonne raison de comprendre quelque chose ne va pas avec des abstractions. Il suffit de garder tout aussi court et simple que possible.

8
Andrey Agibalov

Il y a une pensée de pensée qui dit 7-8 LOC est un peu long pour une méthode. Je ne m'abonne pas à cela, mais je dirais aller aller à l'avance - quelque chose de moins qu'un écran est bon pour moi.

6
mcottle

Les méthodes doivent être aussi simples que nécessaires, mais pas plus simple.

5
Andrew Lewis

Loc n'est tout simplement pas une métrique précieuse. Au lieu de cela, regardez à quel point une méthode fait. Une méthode devrait généralement faire une chose. IMHO, il est parfois correct de faire pipi sur 1 ou 2 opérations très simples. Par exemple, calculer le périmètre d'un rectangle:

Il pourrait être:

public int GetPerimeter(int side1, int side2)
{
    totalWidthLength = side1 * 2;
    totalHeightLength = side2 * 2;
    return totalWidthLength + totalHeightLength;
}

-OU-

public int GetPerimeter(int side1, int side2)
{
    return DoubleSide(side1) + DoubleSide(side2);
}

private int DoubleSide(int side)
{
    return side * 2;
}

Personnellement, je préfère la première méthode, même si elle effectue techniquement plus d'une opération. Dans le même temps, vous pouvez également avoir des méthodes avec de nombreuses lignes de code simples à lire et à comprendre.

public void UpdateCustomer()
{
    customer Customer = new Customer();

    customer.Name = textboxName.Text;
    customer.AddrLine1= textboxName.Text;
    customer.AddrLine2 = textboxName.Text;
    customer.OfficialName = textboxName.Text;
    customer.Age = textboxName.Text;
    customer.BirthDay = textboxName.Text;
    customer.NickName = textboxName.Text;
    customer.LastLocation = textboxName.Text;
    customer.... = textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer.... = textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer.... = textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;
    customer....= textboxName.Text;

    db.InsertOnCommit(customer)
    db.SubmitChanges();
}

L'exemple ci-dessus est d'environ 50 lignes, mais cela pourrait même être de 200 lignes et ne ferait aucune différence. Chaque affectation des biens sur l'objet client ajoute pratiquement aucune complexité, la méthode 50 lignes reste donc au même niveau de complexité que votre méthode moyenne 4 lignes. En fait, j'irais si loin de dire qu'il a fondamentalement la même lisibilité que la méthode ci-dessous:

public void UpdateCustomer()
{
    customer Customer = new Customer();

    customer.Name = textboxName.Text;

    db.InsertOnCommit(customer)
    db.SubmitChanges();
}

La méthode des 50 lignes pourrait probablement être obtenue dans moins de 10 lignes grâce à l'utilisation de la réflexion et de la regex, itérant sur chacune des propriétés du client et de rechercher une zone de texte qui a une valeur similaire à son nom. De toute évidence, ce serait un exemple de code de manière aussi intelligente et des stations de recours à des hacks loufoques pour atteindre un idéal asthétique. La partie finale est que LOC est une métrique de complexité/lisibilité extrêmement peu fiable. Tout le monde le sait déjà (mon exemple de CRUD n'est en aucun cas peu commun), et pourtant, tandis que la plupart des gens parlent de la manière dont Horrible Loc est à mesurer Productivité, nous entendons constamment à propos de ce LOC par des règles de méthode censées mesurer la qualité du code. Cela ne peut vraiment pas être des deux manières.

5
Morgan Herlocker