Programmation SOLID Principes
Au fil du temps, j'ai pu comprendre deux parties de SOLIDE - le "S" et le "O".
"O" - J'ai appris le principe ouvert et fermé à l'aide de l'héritage et du modèle de stratégie.
"S" - J'ai appris le principe de responsabilité unique lors de l'apprentissage de l'ORM (la logique de persistance est retirée des objets du domaine).
De la même manière, quelles sont les meilleures régions/tâches pour apprendre d'autres parties de SOLID (le "L", le "I" et le "D")?
Références
J'étais à votre place il y a quelques mois jusqu'à ce que je trouve un article très utile.
Chaque principe est bien expliqué avec des situations du monde réel auxquelles chaque développeur de logiciels peut être confronté dans ses projets. Je coupe court ici et pointe la référence - Développement logiciel S.O.L.I.D., une étape à la fois .
Comme indiqué dans les commentaires, il existe une autre très bonne lecture de pdf - Pablo's SOLID Software Development .
En outre, il existe de bons livres qui décrivent les principes SOLID plus en détail - Bon livre sur SOLID Développement de logiciels .
Édition et commentaires d'un bref résumé pour chaque principe:
"S" - Le principe de responsabilité unique est déterminé par les besoins de l'entreprise pour permettre le changement. "Une seule raison de changer" vous aide à comprendre quels concepts logiquement distincts doivent être regroupés en considérant le concept et le contexte de l'entreprise, au lieu du seul concept technique.
In another words, j'ai appris que chaque classe devrait avoir une seule responsabilité. La responsabilité est de simplement accomplir la tâche assignée"O" - J'ai appris le principe ouvert fermé et j'ai commencé à "préférer la composition à l'héritage" et en tant que tel, préférant les classes qui n'ont pas de méthodes virtuelles et sont peut-être scellées, mais dépendent des abstractions pour leur extension.
"L" - J'ai appris le principe de substitution de Liskov à l'aide du modèle de référentiel pour gérer l'accès aux données.
- "I" - J'ai appris le principe de ségrégation des interfaces en apprenant que les clients ne devraient pas être obligés d'implémenter des interfaces qu'ils n'utilisent pas (comme dans Membership Provider dans ASP.NET 2.0). L'interface ne devrait donc pas avoir "beaucoup de responsabilités"
- "D" - J'ai appris le principe d'inversion des dépendances et j'ai commencé à coder facilement . Plus facile à changer signifie un coût total de possession inférieur et une maintenabilité plus élevée.
Comme une ressource utile de CodePlex a été mentionnée dans les commentaires, une référence est incluse à SOLID par exemple
(I) La ségrégation d'interface et (D) l'inversion de la dépendance peuvent être apprises via des tests unitaires et des moqueries. Si les classes créent leurs propres dépendances, vous ne pouvez pas créer de bons tests unitaires. S'ils dépendent d'une interface trop large (ou pas d'interface du tout), il n'est pas très évident de se moquer de vous pour effectuer vos tests unitaires.
Liskov Substitution Principle ne vous permet pas de surexploiter l'héritage d'implémentation: vous ne devriez jamais utiliser l'héritage uniquement pour la réutilisation de code (il y a une composition pour cela)! En adhérant à LSP, vous pouvez être à peu près sûr qu'il existe réellement une "relation" est-une "entre votre superclasse et votre sous-classe.
Ce qu'il dit, c'est que vos sous-classes doivent implémenter toutes les méthodes de la sous-classe d'une manière similaire à l'implémentation des méthodes dans la sous-classe. Vous ne devez jamais remplacer une méthode avec l'implémentation de NOP ou retourner null lorsque le supertype lève une exception; Comme indiqué dans les termes Design by Contract, vous devez respecter le contrat de la méthode de la superclasse lorsque vous remplacez une méthode. Un moyen de se défendre contre la violation de ce principe est de ne jamais remplacer une méthode implémentée; extrayez plutôt une interface et implémentez cette interface dans les deux classes.
Principe de ségrégation d'interface, le principe de responsabilité unique et le principe de haute cohésion de GRASP sont en quelque sorte liés; ils se réfèrent au fait qu'une entité ne devrait être responsable que d'une seule chose afin qu'il n'y ait qu'une seule raison de changement afin que le changement se fasse très facilement.
Il dit en fait que si une classe implémente une interface, elle doit implémenter et utiliser toutes les méthodes de cette interface. S'il existe des méthodes qui ne sont pas nécessaires dans cette classe particulière, alors l'interface n'est pas bonne et doit être divisée en deux interfaces dont l'une n'a que les méthodes nécessaires à la classe d'origine. Il peut être considéré à partir d'un POV, qui se rapporte au principe précédent par le fait qu'il ne vous permet pas de créer de grandes interfaces afin que leur implémentation puisse casser LSP.
Vous pouvez voir Inversion de dépendance dans le modèle d'usine; ici à la fois le composant de haut niveau (le client) et le composant de bas niveau (instance individuelle à créer) dépend de l'abstraction (l'interface). Une façon de l'appliquer dans une architecture en couches: vous ne devez pas définir d'interface avec une couche dans la couche qui est implémentée mais dans le module qui est appelé. Par exemple, l'API de la couche de source de données ne doit pas être écrite dans la couche de source de données mais dans la couche logique commerciale, où elle doit être appelée. De cette façon, la couche source de données hérite/dépend du comportement défini dans la logique commerciale (donc l'inversion) et non l'inverse (comme ce serait le cas normalement). Cela offre une flexibilité dans la conception, permettant à la logique métier de fonctionner sans aucun changement de code, avec une autre source de données entièrement différente.