Comment rendre le code réutilisable?

Voir 10 conseils pour écrire du code réutilisable .

1. Conservez le code SEC. Dry signifie “Ne vous répète pas”.
2. Faire une classe / méthode ne fait qu’une chose.
3. Ecrivez des tests unitaires pour vos classes ET simplifiez le test des classes.
4. Supprimer la logique métier ou le code principal de tout code d’infrastructure
5. Essayez de penser de manière plus abstraite et utilisez les interfaces et les classes abstraites.
6. Code d’extension. Ecrivez du code qui peut facilement être étendu dans le futur.
7. N’écrivez pas de code inutile.
8. Essayez de réduire le couplage.
9. Soyez plus modulaire
10. Ecrire du code comme votre code est une API externe

Si vous adoptez l’approche de développement piloté par les tests, votre code ne devient réutilisable qu’en tant que refactor basé sur les scénarios à venir.

Personnellement, je trouve constamment que le refactoring produit un code plus propre que d’essayer de deviner quels scénarios je dois coder pour une classe particulière.

Plus que toute autre chose, la maintenabilité rend le code réutilisable.

La réutilisabilité est rarement un objective valable en soi. Il s’agit plutôt d’un sous-produit de l’écriture de code bien structuré, facilement maintenable et utile.

Si vous souhaitez créer du code réutilisable, vous essayez souvent de prendre en compte les exigences de comportement qui pourraient être requirejses dans les projets futurs. Quelle que soit votre qualité, vous constaterez que ces exigences en matière de protection de l’avenir ne sont pas correctes.

D’un autre côté, si vous commencez avec les exigences du projet actuel, vous constaterez que votre code peut être propre, net et élégant. Lorsque vous travaillez sur un autre projet nécessitant des fonctionnalités similaires, vous allez naturellement adapter votre code d’origine.

Je suggère d’examiner les meilleures pratiques pour votre langage / paradigme de programmation choisi (par exemple, Patterns et SOLID pour les types Java / C #), la documentation de programmation Lean / Agile et (bien sûr) le livre “Code Complete”. Comprendre les avantages et les inconvénients de ces approches améliorera votre pratique de codage. Tout votre code deviendra alors réutilisable – mais “par accident”, plutôt que par conception.

Aussi, voir ici: Rédaction de code maintenable

Pour la plupart des définitions de la “réutilisation”, la réutilisation du code est un mythe, du moins dans mon expérience. Pouvez-vous dire que j’ai des cicasortingces? 🙂

Par réutilisation, je ne veux pas dire prendre des fichiers sources existants et les soumettre à la soumission jusqu’à ce qu’un nouveau composant ou service tombe en panne. Je veux dire prendre un composant ou un service spécifique et le réutiliser sans modification.

Je pense que la première étape consiste à vous mettre dans une mentalité selon laquelle il faudra au moins trois itérations pour créer un composant réutilisable. Pourquoi 3? Parce que la première fois que vous essayez de réutiliser un composant, vous découvrez toujours quelque chose qu’il ne peut pas gérer. Alors, vous devez le changer. Cela se produit plusieurs fois, jusqu’à ce que vous ayez finalement un composant qui semble au moins être réutilisable.

L’autre approche consiste à faire un design prospectif coûteux. Mais alors, le coût est à l’avance et les avantages (éventuellement) apparaissent un peu plus tard. Si votre patron insiste sur le fait que le calendrier actuel du projet domine toujours, cette approche ne fonctionnera pas.

L’orientation des objects vous permet de restructurer le code en superclasses. C’est peut-être le type de réutilisation le plus facile, le moins cher et le plus efficace. L’inheritance de classe ordinaire ne nécessite pas beaucoup de reflection sur “d’autres situations”; vous n’avez pas besoin de construire du code “omnipotent”.

Au-delà de l’inheritance simple, la réutilisation est quelque chose que vous trouvez plus que vous n’inventez. Vous trouvez des situations de réutilisation lorsque vous souhaitez réutiliser un de vos propres packages pour résoudre un problème légèrement différent. Lorsque vous souhaitez réutiliser un package qui ne correspond pas exactement à la nouvelle situation, vous avez deux choix.

1. Copiez-le et corrigez-le. Vous avez maintenant des paquets presque similaires – une erreur coûteuse.

2. Rendre le paquet d’origine réutilisable dans deux situations.

Faites-le simplement pour le réutiliser. Rien de plus. Trop penser à la réutilisation “potentielle” et aux “autres situations” non définies peut devenir une perte de temps.

Vous allez écrire différents modules (parties) lors de l’écriture d’un projet relativement important. En pratique, le code réutilisable signifie que vous créerez des bibliothèques que d’autres projets nécessitant les mêmes fonctionnalités pourront utiliser.

Donc, vous devez identifier les modules qui peuvent être réutilisés, pour cela

1. Identifier la compétence de base de chaque module. Par exemple, si votre projet doit compresser des fichiers, vous aurez un module qui gérera la compression des fichiers. Ne le faites pas faire plus d’une chose. Une seule chose

2. Ecrivez une bibliothèque (ou une classe) qui gérera la compression des fichiers sans avoir besoin de rien de plus que le fichier à compresser, la sortie et le format de compression. Cela découplera le module du rest du projet, lui permettant d’être (re) utilisé dans un autre paramètre.

3. Vous n’êtes pas obligé de le perfectionner la première fois, lorsque vous réutilisez réellement la bibliothèque, vous découvrirez probablement des failles dans la conception (par exemple, vous n’avez pas rendu le module suffisamment modulable pour pouvoir append facilement de nouveaux formats de compression) et vous pouvez les réparer une seconde fois et améliorer la réutilisation de votre module. Plus vous le réutilisez (et corrigez les failles), plus il sera facile de le réutiliser.

La chose la plus importante à prendre en compte est le découplage, si vous écrivez étroitement la réutilisation du code est la première victime.

Laissez tout l’état ou le contexte nécessaire en dehors de la bibliothèque. Ajoutez des méthodes pour spécifier l’état de la bibliothèque.

D’autres ont mentionné ces tactiques, mais elles sont formelles. Ces trois vous mèneront très loin:

• Respectez le principe de la responsabilité unique – cela garantit que votre classe ne fait qu’une chose, ce qui signifie qu’il est plus probable qu’elle soit réutilisable pour une autre application qui inclut la même chose.
• Respectez le principe de substitution Liskov – il garantit que votre code “fait ce qu’il est censé sans surprise”, ce qui signifie qu’il est plus probable qu’il soit réutilisable pour une autre application nécessitant la même chose.
• Respectez le principe d’ouverture / de fermeture – cela garantit que votre code peut se comporter différemment sans modifier sa source, ce qui signifie qu’il est plus susceptible d’être réutilisable sans modification directe.

Pour append aux éléments mentionnés ci-dessus, je dirais:

• Rendre ces fonctions génériques que vous devez réutiliser
• Utiliser des fichiers de configuration et faire en sorte que le code utilise les propriétés définies dans files / db
• Facturez clairement votre code dans des fonctions / classes telles que celles-ci fournissent des fonctionnalités indépendantes et peuvent être utilisées dans différents scénarios et définissent ces scénarios à l’aide des fichiers de configuration.

J’appendais le concept de «composition de classe par rapport à l’inheritance de classe» (dérivé d’autres réponses ici). De cette façon, l’object «composé» ne se soucie pas de la structure interne de l’object dont il dépend – seulement son comportement, ce qui conduit à une meilleure encapsulation et à une maintenabilité plus facile (tests, moins de détails à prendre en compte). Dans les langages tels que C # et Java, il est souvent crucial car il n’ya pas d’inheritance multiple, ce qui permet d’éviter les problèmes d’inheritance.

Comme mentionné, le code modulaire est plus réutilisable que le code non modulaire.

Une façon d’aider au code modulaire consiste à utiliser l’encapsulation, voir la théorie de l’encapsulation ici: http://www.edmundkirwan.com/

Ed.

Évitez de réinventer la roue. C’est tout. Et cela en soi a de nombreux avantages mentionnés ci-dessus. Si vous avez besoin de changer quelque chose, alors vous créez simplement un autre morceau de code, une autre classe, une autre constante, une bibliothèque, etc. Cela vous aide, vous et le rest des développeurs travaillant dans la même application.

Commenter, en détail , tout ce qui peut sembler déroutant lorsque vous reviendrez au code la prochaine fois. Des commentaires excessivement verbeux peuvent être légèrement ennuyeux, mais ils sont bien meilleurs que les commentaires clairsemés, et peuvent vous faire gagner des heures en essayant de comprendre ce que vous faisiez la dernière fois.