web-dev-qa-db-fra.com

Le principe de responsabilité unique est-il applicable aux fonctions?

Selon Robert C. Martin, le SRP indique que:

Il ne devrait jamais y avoir plus d'une raison pour une classe de changer.

Cependant, dans son livre Code de nettoyage , Chapitre 3: Fonctions, il affiche le bloc de code suivant:

    public Money calculatePay(Employee e) throws InvalidEmployeeType {
        switch (e.type) {
            case COMMISSIONED:
                return calculateCommissionedPay(e);
            case HOURLY:
                return calculateHourlyPay(e);
            case SALARIED:
                return calculateSalariedPay(e);
            default:
                throw new InvalidEmployeeType(e.type);
        }
    }

Puis des États:

Cette fonction présente plusieurs problèmes. Tout d'abord, c'est grand et lorsque de nouveaux types d'employés sont ajoutés, il augmentera. Deuxièmement, cela fait très clairement plus d'une chose. Troisièmement, -il viole le principe de responsabilité unique (SRP) car il y a plus d'une raison pour qu'il change. [l'emphase mine]

Premièrement, je pensais que le SRP était défini pour les cours, mais il s'avère que cela s'applique également aux fonctions. Deuxièmement, comment cette fonction a-t-elle plus d'une raison de modifier ? Je ne peux que le voir changer à cause d'un changement d'employé.

design-patternssingle-responsibility
17
Enrique

On a souvent manqué le détail du principe de responsabilité unique, c'est que les "motifs de changement" sont regroupés par les acteurs de l'utilisation (vous pouvez voir une explication complète ici ).

Donc, dans votre exemple, la méthode calculatePay devra être modifiée chaque fois que de nouveaux types d'employés sont nécessaires. Étant donné qu'un type d'employé n'a peut-être rien à voir avec un autre, ce serait une violation du principe si vous les gardez ensemble, car le changement affecterait différents groupes d'utilisateurs (ou des acteurs de cas) dans le système.

Maintenant, sur la question de savoir si le principe s'applique aux fonctions: même si vous avez une violation dans une seule méthode, vous changez toujours une classe pour plus d'une raison, c'est donc toujours une violation de SRP.

13
MichelHenrich

Lorsque M. Martin applique le SRP à une fonction, il étend implicitement sa définition de SRP. Comme le SRP est un libellé spécifique de OO d'un principe général, et comme c'est une bonne idée lorsqu'il est appliqué aux fonctions, je ne vois pas de problème avec cela (bien que cela aurait pu être bien s'il était explicitement inclus dans le définition).

Je ne vois pas plus d'une raison de changer non plus, et je ne crois pas que la pensée du SRP en termes de "responsabilités" ou de "raisons de changer" est utile. Essentiellement ce que le SRP obtient est que les entités logicielles (fonctions, classes, etc.) devraient faire une chose et le faire bien.

Si vous regardez ma définition, ce n'est pas moins vague que le libellé habituel du SRP. Le problème avec les définitions habituelles du SRP n'est pas que ce sont trop vagues, mais qu'ils essaient d'être trop spécifiques sur quelque chose qui est essentiellement vague.

Si vous regardez ce que fait calculatePay, cela fait clairement une seule chose: Dispatch basé sur le type. Depuis Java a des façons intégrées d'effectuer une envoi basée sur le type, calculatePay est inélégant et non idiomatique, de sorte qu'il devrait être réécrit, mais pas pour les raisons indiquées.

3
Michael Shaw

À la page 176, chapitre 12: émergence, dans la section intitulée classes et méthodes minimales Le livre fournit un peu une correction, en déclarant:

Dans le but de rendre nos cours et méthodes petites, nous pourrions créer trop de classes et méthodes de minuscules. Cette règle suggère donc que nous gardons également notre fonction et nos comptes de classe bas

et

Les chiffres de haute classe et de méthode sont parfois le résultat d'un dogmatisme inutile.

De toute évidence, il parle de dogmatisme dans la suite du SRP pour décomposer parfaitement de petites méthodes innocentes telles que calculatePay() ci-dessus.

2
Mike Nakis