Que devrait-il y avoir sur une liste de vérification qui aiderait quelqu'un à développer un bon logiciel D'OO?

j'ai utilisé des langages et des techniques de programmation OO il y a des années (principalement sur C++) mais dans l'intervalle je n'ai pas fait grand chose avec OO.

je commence à faire un petit utilitaire en C#. Je pourrais tout simplement le programmer sans utiliser de bonnes pratiques D'OO, mais ce serait un bon rafraîchissement pour moi d'appliquer des techniques d'OO.

comme les niveaux de normalisation des bases de données, je cherche une liste de contrôle qui me rappellera les différentes règles empiriques pour un' bon ' objet orienté programme-une liste concise oui / non que je peux lire à l'occasion pendant la conception et la mise en œuvre pour m'empêcher de penser et de travailler de façon procédurale. Il serait encore plus utile qu'elle contienne les Termes et concepts OO appropriés, de sorte que tout élément de contrôle soit facilement consultable pour obtenir de plus amples informations.

Qu'y a-t-il sur une liste de vérification qui pourrait aider quelqu'un à développer un bon logiciel D'OO?

a L'inverse, quels "tests" pourraient être appliqués qui montreraient que le logiciel n'est pas OO?

24
demandé sur Adam Davis 2009-05-27 17:18:38
la source

12 ответов

on dirait que vous voulez des questions de base oui/non pour vous poser le long de votre chemin. Tout le monde a donné quelques grandes listes de "faire ceci" et "penser comme ça", alors voici mon crack à quelques simples oui/non.

je Peux répondre oui à toutes ces?

  • Est-ce que mes cours représentent les noms qui m'intéressent?
  • Est-ce que mes classes fournissent des méthodes pour les actions/verbes qu'elles peuvent effectuer?

puis - je répondre non à tous les ces?

  • Est-ce que j'ai des données globales d'état qui pourraient être soit mises dans un singleton ou stockées dans des implémentations de classe qui fonctionnent avec ça?
  • puis-je supprimer des méthodes publiques sur une classe et les ajouter à une interface ou les rendre privées/protégées pour mieux encapsuler le comportement?
  • devrais-je utiliser une interface pour séparer un comportement des autres interfaces ou de la classe d'implémentation?
  • est-ce que j'ai un code qui est répété entre les classes que je peux déplacer dans une classe de base pour une meilleure réutilisation de code et abstraction?
  • est-ce que je teste le type de quelque chose pour décider ce qu'il faut faire? Si c'est le cas, ce comportement peut-il être inclus sur le type de base ou l'interface que le code en question utilise pour permettre une utilisation plus efficace de l'abstraction ou le code en question devrait-il être remanié pour utiliser une meilleure classe de base ou interface?
  • est-ce que je vérifie à plusieurs reprises des données de contexte pour décider quel type instancier? Si oui cela peut-il être résumé dans un modèle de conception d'usine pour une meilleure abstraction de la logique et de la réutilisation de code?
  • Est une classe très grande, avec plusieurs axes de fonctionnalité? Si si je peux le diviser en plusieurs classes, chacune avec leur propre but unique?
  • ai-je des classes sans rapport héritant de la même classe de base? Si c'est le cas, puis-je diviser la classe de base en de meilleures abstractions ou Puis-je utiliser la composition pour accéder à la fonctionnalité?
  • A mon hiérarchie d'héritage terriblement profond? Si c'est le cas, puis-je l'aplatir ou séparer les choses par l'intermédiaire d'interfaces ou de fonctions de fractionnement?
  • je me suis trop inquiété de ma hiérarchie de l'héritage?
  • quand j'explique le dessin à un canard en caoutchouc est-ce que je me sens stupide à propos du dessin ou stupide de parler à un canard?

Juste quelques quick sur le dessus de ma tête. J'espère que ça aidera, OOP peut devenir assez fou. Je n'ai pas inclus De oui / non pour plus avancé les choses qui sont généralement un problème avec les applications plus grandes, comme l'injection de dépendances ou si vous devez diviser quelque chose en différents services/couches/assemblages logiques....bien sûr, j'espère que vous allez au moins séparer votre UI de votre logique.

8
répondu Sean Copenhaver 2009-11-06 00:06:03
la source
  • Objets choses. (Point le plus important dans L'ensemble de OOP!) ne les considérez pas comme des" détenteurs de données " - envoyez-leur un message pour faire quelque chose. Quels verbes ma classe? L'école de pensée du" Design axé sur la responsabilité " est brillante à cet égard. (Voirconception de L'objet: rôles, responsabilités et Collaborations, Rebecca Wirfs-Brock and Alan McKean, Addison-Wesley 2003, ISBN 0201379430.)
  • pour chaque chose le le système doit faire, trouver un tas de scénarios concrets décrivant comment les objets se parlent entre eux pour faire le travail. Cela signifie penser en termes de diagrammes d'interaction et donner suite aux appels de méthode. - Ne commence pas avec un diagramme de classe - C'est SQL-penser pas oo-penser.
  • Apprendre Le Développement Basé Sur Les Tests.Personne obtient leur modèle d'objet directement à l'avant mais si vous faites TDD vous mettez dans le travail de base pour s'assurer que votre le modèle d'objet fait ce dont il a besoin et le rend sécuritaire pour se reformuler quand les choses changent plus tard.
  • Seulement de construire pour les besoins que vous avez maintenant - ne vous obstinez pas sur la "réutilisation" ou des choses qui seront "utiles plus tard". Si vous construisez seulement ce dont vous avez besoin maintenant, vous gardez l'espace de conception des choses que vous pourriez faire plus tard beaucoup plus ouvert.
  • oubliez l'héritage quand vous modelez des objets. c'est juste une façon d'implémenter un code commun. Lorsque vous modélisez des objets, faites comme si vous regardiez chaque objet à travers une interface qui décrit ce qu'on peut lui demander de faire.
  • Si une méthode est nécessaire d'avoir beaucoup de paramètres ou si vous avez besoin d'appeler à plusieurs reprises un tas d'objets pour obtenir beaucoup de données, la méthode pourrait être dans la mauvaise classe. le meilleur endroit pour une méthode est juste à côté de la plupart des champs qu'elle utilise dans la même classe (ou superclasse ...)
  • Lire un livre de dessins pour votre langue. si C'est C#, essayez "Design Patterns in C#" de Steve Metsker. Cela vous apprendra une série de trucs que vous pouvez utiliser pour diviser le travail entre les objets.
  • ne testez pas un objet pour voir quel type il est et ensuite prendre des mesures basées sur ce type - c'est une odeur de code que l'objet devrait probablement faire le travail. C'est un indice que vous devriez appeler l'objet et lui demander de faire le travail. (Si seulement certains types d'objets, faire le travail, vous pouvez tout simplement ne rien faire" implémentations dans certains objets... C'est légitime de la programmation orientée objet.)
  • mettre les méthodes et les données dans les bonnes classes rend le code OO plus rapide (et donne aux machines virtuelles une chance de mieux optimiser) - ce n'est pas seulement esthétique ou théorique. Le Sharble et Cohen étude des points de ce hors - voir http://portal.acm.org/citation.cfm?doid=159420.155839 (Voir le graphique de mesures sur le "nombre d'instructions exécutées par le scénario")
35
répondu daf 2009-10-30 04:43:33
la source

recueillis à partir de divers livres, célèbres programmeurs C#, et des conseils généraux (pas grand chose si tout cela est le mien; il est dans le sens que ce sont diverses questions que je me pose pendant le développement, mais c'est tout):

  • structures ou Classes? est l'élément que vous créez une valeur propre, faites-en une structure. Si c'est un" objet " avec des attributs et des sous-valeurs, des méthodes, et éventuellement un État, alors en faire un objet.
  • Classes Scellées: Si vous allez créer une classe et vous ne devez pas explicitement être en mesure d'hériter de lui faire scellé. (Je le fais pour le prétendu gain de performance)
  • Ne pas Répéter: si vous vous trouvez en train de copier du code(a/e), alors vous devriez probablement (mais pas toujours) repensez votre conception pour minimiser la duplication de code.
  • Si vous n'avez pas besoin de fournir une implémentation de base pour une classe abstraite de le transformer en un interface.
  • le principe de spécialisation: Chaque objet que vous avez ne devrait faire qu'une chose. Cela permet d'éviter "L'objet-Dieu".
  • utiliser les propriétés pour un accès public: Cela a été débattu maintes et maintes fois, mais c'est vraiment la meilleure chose à faire. Les propriétés Vous permettent de faire des choses que vous ne pouvez normalement pas faire avec les champs, et il vous permet également plus de contrôle sur la façon dont l'objet est obtenu et défini.
  • Singletons: autre sujet controversé, et voici l'idée: utiliser uniquement quand vous en avez Absolument Besoin. La plupart du temps un tas de méthodes statiques peuvent servir l'objectif d'un singleton. (Bien que si vous avez absolument besoin d'un modèle singleton utiliser Jon Skeet est un excellent)
  • couplage Lâche: assurez-vous que vos classes dépendent l'une de l'autre aussi peu que possible; assurez-vous qu'il est facile pour les utilisateurs de votre bibliothèque d'échanger des parties de votre bibliothèque avec d'autres (ou personnalisé construit portion.) Cela comprend l'utilisation d'interfaces, si nécessaire, l'Encapsulation (d'autres l'ont mentionné), et la plupart du reste de l'principes dans cette réponse.
  • Conception avec la simplicité à l'esprit: Contrairement glaçage à gâteau, il est plus facile de concevoir quelque chose de simple et d'ajouter plus tard il est de conception complexe et supprimer plus tard.

j'ai peut-chuck certains ou la totalité de cette la porte si je fais:

  • Rédaction personnelle le projet
  • vraiment pressé de faire quelque chose (mais je vais y revenir plus tard.... autrefois..... ;))

ces principes guident mon codage quotidien et ont grandement amélioré ma qualité de codage dans certains domaines! espérons que ça aide!

9
répondu RCIX 2009-12-08 10:53:48
la source

Steve Mcconnell's Code Terminé 2 contient beaucoup de listes de contrôle prêtes à l'emploi pour une bonne construction logicielle.

Robert C. Martin's Agile Principes, Modèles et Pratiques en C# contient beaucoup de principes pour une bonne OO desgin.

les Deux vous donnera une base solide pour commencer.

7
répondu ivo 2009-05-27 17:36:27
la source
  • Données appartient avec le code qui fonctionne sur (c'est à dire dans la même classe). Cela améliore la maintenabilité car de nombreux champs et méthodes peuvent être privés (l'encapsulation) et sont donc, dans une certaine mesure, écartées de la considération lorsqu'on examine l'interaction entre les composantes.
  • Utilisez le polymorphisme au lieu des conditions - chaque fois que vous devez faire des choses différentes en fonction de ce qu'est la classe d'un objet, essayez de mettre ce comportement dans une méthode que différentes classes mettent en œuvre différemment de sorte que tout ce que vous avez à faire est d'appeler cette méthode
  • utiliser l'héritage avec parcimonie, privilégier la composition - L'héritage est une caractéristique distinctive de la programmation OO et souvent considérée comme "l'essence" de L'OOP. Il est en fait gravement surutilisé et devrait être classé comme l'élément le moins important
7
répondu Michael Borgwardt 2009-05-27 18:05:49
la source

une des meilleures sources serait le livre de Martin Fowler "Refactoring" qui contient une liste (et des détails à l'appui) d'odeurs de code orientées objet que vous pourriez vouloir envisager refactoring.

je recommande également les listes de contrôle du "code propre"de Robert Martin.

6
répondu Rob Scott 2009-06-05 03:05:11
la source
  • ai-je clairement défini exigences? exigences formelles la documentation n'est peut-être pas nécessaire, mais vous devriez avoir une vision claire avant de commencer à coder. Les outils de Mind-mapping et les prototypes ou les croquis de conception peuvent être de bonnes solutions de rechange si vous n'avez pas besoin de documentation officielle. Travailler avec les utilisateurs finaux et les intervenants le plus tôt possible dans le processus logiciel, pour s'assurer que vous mettez en œuvre ce dont ils ont besoin.

  • Suis-Je réinventer la roue? si vous codez pour résoudre un problème commun, recherchez une bibliothèque robuste qui résout déjà ce problème. Si vous pensez que vous avez peut-être déjà résolu le problème ailleurs dans votre code (ou un collègue pourrait avoir), cherchez d'abord une solution existante.

  • mon objet clair et unique but? Suivant le principe de l'Encapsulation, un objet doit avoir le comportement avec les données qu'il exploite. Un l'objet ne devrait avoir qu'une seule responsabilité majeure.

  • puis-je coder à une interface? la conception par contrat est un excellent moyen de permettre les essais unitaires, de documenter les exigences détaillées au niveau de la classe et d'encourager la réutilisation du code.

  • puis-je mettre mon code en cours de test? le développement basé sur les tests (TDD) n'est pas toujours facile, mais les tests unitaires sont précieux pour le remaniement et la vérification du comportement de régression après avoir fait des changements. Aller main dans la main avec le Design par contrat.

  • Est-ce que j'exagère? N'essayez pas de coder un composant réutilisable. N'essayez pas de prévoir les besoins futurs. Ces choses peuvent sembler contre-intuitif, mais elles conduisent à une meilleure conception. La première fois que vous codez quelque chose, il suffit de l'appliquer aussi directement que possible, et faire en sorte qu'il fonctionne. La deuxième fois que vous utilisez la même logique, copier et coller. Une fois que vous avez deux sections de code avec la logique commune, vous pouvez facilement remanier sans essayer d'anticiper les besoins futurs.

  • Est-ce que j'introduis le code de correction? ne vous répétez pas (à sec) est le principal moteur de la refonte. N'utilisez le copier-coller que comme première étape pour le recadrage. Ne codez pas la même chose à des endroits différents, c'est un cauchemar d'entretien.

  • S'agit-il d'un motif courant, d'un motif anti-motif ou d'une odeur de code? Être familier avec la commune solutions aux problèmes de conception OO, et les rechercher comme vous code-mais n'essayez pas de forcer un problème pour correspondre à un certain modèle. Méfiez-vous du code qui tombe dans un modèle de "mauvaise pratique" commune.

  • mon code trop serré? le couplage lâche est un principe qui tente de réduire les interdépendances entre deux ou plusieurs classes. Certaines dépendances sont nécessaires; mais plus vous êtes dépendante d'une autre classe, plus vous avez à résoudre lorsque cette classe changement. Ne laissez pas le code d'une classe dépendre des détails d'implémentation d'une autre classe - utilisez un objet uniquement selon son contrat.

  • Est-ce que j'expose trop d'informations? exercez-vous à cacher des informations. Si une méthode ou un domaine n'a pas besoin d'être public, rendez-le privé. N'exposez que l'API minimale nécessaire pour qu'un objet remplisse son contrat. Ne pas rendre les détails de la mise en œuvre accessibles au client objet.

  • Est-ce que je code défensivement? vérifiez les conditions d'erreur et échouez rapidement. N'ayez pas peur d'utiliser des exceptions, et laissez-les se propager. Dans le cas où votre programme atteint un état inattendu, il est beaucoup, beaucoup mieux d'avorter une opération, enregistrer une trace de pile pour vous de travailler avec, et éviter le comportement imprévisible dans votre code en aval. Suivez les meilleures pratiques pour nettoyer les ressources, comme le using() {} déclaration.

  • vais-je pouvoir lire ce code dans six mois? le bon code est lisible avec un minimum de documentation. Mettez des commentaires là où c'est nécessaire; mais écrivez aussi du code qui est intuitif, et utilisez des classes, des méthodes et des noms de variables significatifs. Si vous travaillez sur un projet d'équipe, chaque membre de l'équipe devrait écrire un code qui ressemble au même.

  • Est-ce que ça marche toujours? tester tôt, tester souvent. Après avoir introduit de nouvelles fonctionnalités, retournez en arrière et touchez tout comportement existant qui pourrait avoir été affecté. Demandez à d'autres membres de l'équipe d'examen par les pairs et de tester votre code. Relancez les tests unitaires après les changements et tenez-les à jour.

6
répondu RMorrisey 2009-11-03 20:15:09
la source
  • solide
  • sec
  • TDD
  • la Composition au cours de l'héritage
5
répondu eglasius 2009-11-04 02:40:43
la source

assurez-vous de lire et de comprendre la suite

  • Encapsulation
    • (en vous assurant que vous n'exposez que l'état et les fonctionnalités minimales pour faire le travail)
  • Polymorphisme
    • (Possibilité pour les objets dérivés à se comporter comme leurs parents)
  • La différence entre une interface et une classe abstraite
    • (Une classe abstraite permet fonctionnalité et état à être partager avec ses descendants, une interface est seulement la promesse que le la fonctionnalité sera implémentée)
3
répondu Alex 2009-05-27 18:00:31
la source

j'aime liste, quoique peut-être un peu dense pour être utilisé comme une liste de contrôle.

1
répondu Hooray Im Helping 2009-05-27 17:29:06
la source

le langage de modélisation UML (Unified Modeling Language), pour la modélisation d'objet et définition de la structure et des relations entre les classes

http://en.wikipedia.org/wiki/Unified_Modeling_Language

puis bien sûr les techniques de programmation pour OO (la plupart déjà mentionnées)

  • Se Cacher De L'Information
  • Abstraction
  • Interfaces
  • Encapsulation
  • Héritage / Le polymorphisme
1
répondu CRice 2009-10-30 04:05:16
la source

Certaines règles sont de langue agnostique, certaines règles diffèrent d'une langue à l'autre.

voici quelques règles et commentaires qui contredisent certaines autres règles publiées précédemment:

  • OO a 4 principes: Abstraction, Encapsulation, polymorphisme et héritages.

    Lisez à leur sujet et gardez-les à l'esprit.

  • modélisation - vos classes sont supposées modéliser des entités dans le problème domaine:

    Divisez le problème en sous-domaines (packages/namespaces / assemblies)

    divisez ensuite les entités de chaque sous-domaine en classes.

    Les Classes devraient contenir des méthodes qui modèlent ce que font les objets de ce type.

  • utilisez UML, pensez aux exigences, aux cas d'utilisation, puis aux diagrammes de classe, aux séquences de ceux-ci. (applicable principalement pour la conception de haut niveau - classes principales et les processus.)

  • Modèles de Conception - bon concept pour n'importe quelle langue, la mise en œuvre diffère d'une langue à l'autre.

  • Struct vs classe en C# c'est une question de la transmission des données par valeur ou par référence.

  • Interface vs. base-class, est une base-class, fait une interface.

  • TDD-ce n'est pas OO, en fait, il peut causer un manque de conception et conduire à beaucoup de réécriture. (Scrum par exemple recommande contre, pour XP c'est un devoir.)

  • la réflexion de C#l'emporte d'une certaine façon sur OO (par exemple la sérialisation basée sur la réflexion), mais elle est nécessaire pour les cadres avancés.

  • assurez-vous que les classes ne "connaissent" pas les autres classes à moins qu'elles n'y soient obligées, en se divisant en assemblées multiples et en étant peu nombreuses avec des références aide.

  • AOP (Aspect Oriented Programming) améliore OOP, (voir PostSharp par exemple) d'une manière qui est si révolutionnaire que vous on devrait au moins regarder leur clip.

  • pour C#, lire les directives de MS (consulter les directives dans L'index de MSDN de SV).), ils ont beaucoup de directives et de conventions utiles là-bas

  • livres Recommandés:

    Lignes directrices de conception de cadre: Conventions, idiomes et modèles pour les bibliothèques réutilisables .NET

    C # 3.0 en un mot!--7-->

1
répondu Danny Varod 2009-11-03 01:56:15
la source

Autres questions sur