Comment rendre le code réutilisable?

si vous optez pour une approche de développement basée sur des tests, votre code ne sera réutilisable que comme votre réflecteur en fonction des scénarios à venir.

personnellement, je trouve que le remaniement constant produit du code plus propre que d'essayer de deviner quels scénarios je dois coder une classe particulière pour.

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

la réutilisation est rarement un objectif valable en soi. Il s'agit plutôt d'un sous-produit du code d'écriture qui est bien structuré, facilement maintenable et utile.

si vous avez l'intention de faire du code réutilisable, vous vous retrouvez souvent à essayer de tenir compte des exigences de comportement qui pourraient être nécessaires dans les projets futurs. N'importe comment bon vous devenez à cela, vous trouverez que vous vous trompez sur les exigences de protection de l'avenir.

d'un autre côté, si vous commencez avec les exigences nues du projet actuel, vous trouverez que votre code peut être propre et serré et élégant. Lorsque vous travaillez sur un autre projet qui nécessite des fonctionnalités similaires, vous adapterez naturellement votre code original.

je suggère d'examiner les meilleures pratiques pour le langage / paradigme de programmation que vous avez choisi (p. ex. Patterns et SOLID pour Java / C# types), la littérature de programmation allégée / Agile, et (bien sûr) le livre "Code complet". Comprendre les avantages et les inconvénients de ces approches améliorera votre pratique de codage sans fin. Tout votre code sera alors réutilisable - mais "par accident", plutôt que par conception.

aussi, voir ici: Writing maintenable Code

Pour la plupart des définitions de "réutilisation", la réutilisation de code est un mythe, au moins dans mon expérience. Tu peux me dire que j'ai des cicatrices? :- )

par réutilisation, Je ne veux pas dire prendre les fichiers source existants et les battre dans la soumission jusqu'à ce qu'un nouveau composant ou service tombe. Je veux dire prendre un composant ou un service spécifique et le réutiliser sans modification.

je pense que la première étape est de vous mettre dans un État d'esprit que cela va prendre à moins de 3 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 avez de la changer. Cela se produit quelques fois, jusqu'à ce que finalement vous ayez un composant qui semble au moins être réutilisable.

l'autre approche consiste à réaliser un design avant-gardiste coûteux. Mais alors le coût est tout d'abord, et les avantages (peuvent) apparaître un certain temps plus tard dans la route. Si votre patron insiste sur le fait que le calendrier actuel du projet domine toujours, alors cette approche ne fonctionnera pas.

objet-orientation vous permet de reformuler le code en superclasses. Il s'agit peut-être du type de réutilisation le plus facile, le moins coûteux et le plus efficace. L'héritage de classe ordinaire ne nécessite pas beaucoup de réflexion sur "d'autres situations"; vous n'avez pas à construire le code "omnipotent".

au-delà de l'héritage simple, la réutilisation est quelque chose que vous trouvez plus que vous inventez. Vous trouvez des situations de réutilisation lorsque vous voulez réutiliser un de vos propres paquets pour résoudre un problème légèrement différent problème. Lorsque vous voulez réutiliser un paquet qui ne correspond pas exactement à la nouvelle situation, vous avez deux choix.

1. Copiez-le et fixez-le. Vous devez maintenant presque les mêmes paquets -- une erreur coûteuse.

2. rendre l'emballage d'origine réutilisable dans deux situations.

il suffit de le faire pour la réutilisation. Rien de plus. Trop de réflexion sur la réutilisation "potentielle" et les "autres situations" non définies peuvent devenir une perte de temps.

vous écrirez divers modules (pièces) lors de la rédaction d'un projet relativement grand. Code réutilisable dans la pratique signifie que vous aurez créer des bibliothèques que d'autres projets ayant besoin de cette même fonctionnalité peuvent utiliser.

ainsi, vous devez identifier les modules qui peuvent être réutilisés, pour que

1. identifier la compétence de base de chaque module. Par exemple, si votre projet doit compresser des fichiers, vous aurez un module qui traitera les fichiers compression. Faire PAS en faire plus UNE CHOSE . Une seule chose.

2. écrivez une bibliothèque (ou une classe) qui traitera la compression de fichiers, sans avoir besoin de quoi que ce soit de plus que le fichier à compresser, la sortie et le format de compression. Cela découplera le module du reste du projet, lui permettant d'être (ré)utilisé dans un contexte différent.

3. vous ne devez pas l'obtenir parfait la première fois, lorsque vous réutilisez réellement la bibliothèque, vous découvrirez probablement des défauts dans la conception (par exemple, vous ne l'avez pas fait assez modulaire pour être en mesure d'ajouter de nouveaux formats de compression facilement) et vous pouvez les corriger la deuxième fois et améliorer la réutilisabilité de votre module. Plus vous le réutilisez (et corrigez les défauts), plus il sera facile de le réutiliser.

la chose La plus importante à considérer est découplage, si vous écrivez étroitement couplé code réutilisabilité est la première victime.

laisser tout l'état ou le contexte nécessaire à l'extérieur de la bibliothèque. Ajouter des méthodes pour spécifier l'état de la bibliothèque.

D'autres ont mentionné ces tactiques, mais ici elles sont formelles. Ces trois-là vous mèneront très loin:

• adhérer à la Responsabilité Unique Principe - il assure votre classe seulement" fait une chose", ce qui signifie qu'il est plus probable qu'il sera réutilisable pour une autre application qui comprend la même chose.
• adhèrent au Liskov Principe de Substitution - il assure votre code "fait ce qu'il est supposé sans surprises", ce qui signifie qu'il est plus probable qu'il sera réutilisable pour une autre application qui a besoin de la même chose fait.
• adhère au Principe Ouvert/Fermé - il assure votre code peut être fait à se comporter différemment sans modifier sa source, ce qui signifie qu'il est plus susceptible d'être réutilisable sans modification directe.

pour ajouter aux articles mentionnés ci-dessus, je dirais:

• faire ces fonctions génériques dont vous avez besoin pour réutiliser
• utiliser des fichiers de configuration et faire en sorte que le code utilise les propriétés définies dans files / db
• factor votre code dans de telles fonctions / classes que celles-ci fournissent une fonctionnalité indépendante et peuvent être utilisées dans différents scénarios et définir ces scénarios en utilisant les fichiers de configuration

j'ajouterais le concept de" composition de classe sur héritage de classe " (qui est dérivé d'autres réponses ici). De cette façon, l'objet" composé " ne se soucie pas de la structure interne de l'objet dont il dépend - seulement de son comportement, ce qui conduit à une meilleure encapsulation et à une maintenabilité plus facile (test, moins de détails à prendre en compte). Dans les langues comme C# et Java, c'est souvent crucial car il n'y a pas d'héritage multiple, donc cela aide à éviter l'héritage graphique enfer u pourrait avoir.

comme nous l'avons mentionné, le code modulaire est plus réutilisable que le code non modulaire.

une façon d'aider vers le code modulaire est d'utiliser l'encapsulation, voir la théorie de l'encapsulation ici: http://www.edmundkirwan.com /

Ed.

Éviter 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 juste un autre morceau de code, une autre classe, une autre constante, une bibliothèque, etc... il aide vous et le reste des développeurs travaillant dans la même application.

Comment, in detail , tout ce qui semble comme il pourrait être déroutant quand vous revenez au code la prochaine fois. Les commentaires excessivement verbeux peuvent être légèrement agaçants, mais ils sont bien meilleurs que les commentaires épars, et peuvent sauver des heures d'essayer de comprendre WTF que vous faisiez la dernière fois.