Existe-t-il un contre-modèle pour décrire cette méthode de codage? [fermé]

J'ai une base de code où le programmeur avait tendance à boucler les choses dans des domaines qui n'ont pas de sens. Par exemple, étant donné un journal d'erreurs que nous avons, vous pouvez vous connecter via

ErrorLog.Log(ex, "friendly message");

Il a ajouté divers autres moyens pour accomplir exactement la même tâche. PAR EXEMPLE

SomeClass.Log(ex, "friendly message");

Ce qui se retourne simplement et appelle la première méthode. Cela ajoute des niveaux de complexité sans aucun avantage supplémentaire. Existe-t-il un anti-modèle pour décrire cela?

Il ne vaut la peine d'appeler une mauvaise habitude de codage un Antipattern que si elle est raisonnablement répandue.

Le reste que nous appelons simplement "code poubelle" ...

Si je devais suggérer un nom pour cette mauvaise habitude, ce serait "Trouble obsessionnel de l'abstraction" :-)

Non, ce n'est pas un anti pattern mais je voudrais soulever les problèmes suivants.

Violation du principe de responsabilité unique

SRP dit qu'une classe devrait avoir une raison de changer. L'ajout d'une méthode de journalisation signifie que la classe doit également changer si la logique de journalisation doit être modifiée.

Violation d'un is-a relation

Les classes de base ne sont pas des boîtes à outils dans lesquelles vous pouvez ajouter plusieurs méthodes pratiques.

Cela permet de coupler efficacement toutes les classes héritées aux implémentations de la classe de base.

Comparez cela avec la composition.

Non pas que cela le rend acceptable, mais cela pourrait simplement être une refactorisation inachevée. Peut-être que SomeClass.log () avait sa propre logique et a été implémenté en premier. Et plus tard, ils ont réalisé qu'ils devraient utiliser ErrorLog.Log (). Ainsi, plutôt que de changer 100 emplacements où SomeClass.Log () est appelé, ils ont simplement délégué à ErrorLog.Log (). Personnellement, je changerais toutes les références à ErrorLog.Log () ou au moins commenter SomeClass.log () pour dire pourquoi il délègue la façon dont il le fait.

Juste quelque chose à considérer.

Le terme "Code Lasagne" me vient à l'esprit, bien qu'apparemment il signifie des choses différentes pour différentes personnes . Mon interprétation a toujours été "superposée pour être superposée".

Je ne suis pas sûr de décrire cela comme une infraction au principe de responsabilité unique, car s'il y a un changement dans la signature de la méthode ErrorLog (la méthode appelée par SomeClass), chaque code client qui appelle cette méthode échouera.

Il existe évidemment un moyen d'utiliser l'héritage (ou de créer des classes nécessitant une journalisation en implémentant une interface de journalisation).

Ou nous pourrions considérer cela comme un "moment d'apprentissage" :)

Votre développeur est peut-être à mi-chemin d'une bonne idée. Supposons que vous souhaitiez exiger que tous vos objets métier soient capables d'une journalisation intelligente. Vous pouvez définir:

   public interface IBusinessObjectLogger
   {
       void Log(Exception ex, string logMessage)
   }

Désormais interne à vos objets, vous pouvez utiliser l'objet ErrorLog pour effectuer réellement la journalisation tandis que le code SomeClass ajoute une valeur spécifique à l'objet au message de journal. Vous pouvez ensuite étendre davantage vos API de journalisation pour implémenter la fonctionnalité de journalisation basée sur des fichiers, des bases de données ou des messages sans toucher à vos objets métier.

Je ne suis pas sûr que ce soit automatiquement mauvais.

Si vous appelez SomeClass.Log, c'est certainement mal, mais si Log est uniquement utilisé à partir de WITHIN SomeClass, cela coupe le couplage et je l'appellerais acceptable.

Ceci est en fait assez courant dans certains styles de codage, et les bases de la ligne de pensée ne sont pas, en elles-mêmes, un anti-modèle.

C'est très probablement le résultat d'un codage par nécessité sans connaissance de la base de code plus large: "OK, ce code doit enregistrer une erreur, mais cette fonction n'est pas l'objectif principal du code. Par conséquent, j'ai besoin d'une méthode / classe qui le fera pour moi". C'est une bonne façon de penser; mais, sans savoir que ErrorLog existait, ils ont créé SomeClass. Ils ont ensuite trouvé ErrorLog à un moment ultérieur, et plutôt que de remplacer toutes les utilisations de la méthode qu'ils avaient mise, ils ont appelé leur méthode ErrorLog. C'est là que cela devient un problème.

Complexité accidentelle est la complexité qui survient dans les programmes informatiques ou leur processus de développement qui n'est pas essentielle au problème à résoudre. Alors que la complexité essentielle est inhérente et inévitable, la complexité accidentelle est causée par l'approche choisie pour résoudre le problème.

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

Il peut s'agir d'un abus / d'une mauvaise compréhension du modèle de façade . J'ai vu des choses similaires dans une base de code avec laquelle j'ai travaillé. Les développeurs sont passés par une phase où ils étaient fous des modèles de conception sans comprendre les principes généraux de la conception OO.

Une mauvaise utilisation du motif de façade entraîne un flou des niveaux d'abstraction à travers les couches de l'application.

Ce que fait ce programmeur, c'est encapsuler du code, afin qu'il n'ait pas de dépendance directe sur le module de journalisation. Sans informations plus spécifiques, il n'est pas possible de donner un modèle plus spécifique. (Que ces emballages ne soient pas utiles est votre opinion qui est impossible à approuver ou à refuser sans beaucoup plus d'informations.)

Les modèles auxquels cela peut appartenir sont Proxy , Délégué , Décorateur , Composite ou certains de ceux qui ont trait à l'habillage, au masquage ou à la distribution des appels. Il peut être l'une de ces choses dans un état de développement incomplet.

Je pourrais imaginer que ce soit une différence culturelle. Il y a peut-être une bonne raison d'avoir des fonctionnalités en double dans cette base de code particulière. Je pourrais imaginer la facilité d'écriture comme une telle raison. Le programmeur Python en moi dirait toujours que c'est mauvais, car " Il devrait y en avoir un - et de préférence un seul - une manière évidente de le faire ", mais certains gars de Perl pourraient être habitués au fait qu'il y en a plus d'un façon de le faire ".