ajoute cette classe hiérarchiquement un anti-

Question

J'ai eu quelques cours comme celui-ci:

+---+    +---+ 
| L | ---uses---> | D | 
+---+    +---+ 
    |    +---+ 
inherit ----<---- | V | 
    |  +---+ +---+ 
    +---<--- | C | 
      +---+ 

Disons; La classe L est une classe abstraite, et V et C en hérite. Et L ont une propriété de classe D. - désolé pour mon mauvais dessin et aussi ANGLAISE

Maintenant, je dois ajouter une nouvelle classe - RA - qui a une propriété de classe et la classe DV devrait avoir une propriété de classe RA, mais je dois aussi obtenir propriété des objets de la classe L Donc V. Dans mon esprit quelque chose comme ceci:

+---+   +---+   +----+ 
| L | --uses--> | D | <--uses-- | RA | 
+---+   +---+   +----+ 
    |    +---+   | 
inherit ----<----| V | --uses-->--+ 
    |  +---+ +---+ 
    +---<---| C | 
      +---+ 

Je ne suis pas sûr !; Mais cela me semble être un anti-pattern ou un briseur de LSP - du principe SOLID - en quelque sorte !, mais je ne peux pas le comprendre.

Mon nouveau diagramme est-il un anti-pattern? ou y a-t-il une meilleure façon de concevoir cette situation?

Notez que des classes telles que D, V, C et RA peuvent être instanciées.
Et je voulais dire que l'utilisation de la propriété de la classe D est maintenant hiérarchiquement dans la classe V.

Edit:
Imaginez que j'utilise une interface - IGFP - qui a retourné une valeur string en utilisant D propriété L donc dans V et C, maintenant V je dois la remplacer en utilisant RA au lieu de D .
Dans les classes C# sont:

public abstract class L : VOBase<L>, IGFP { 
    public virtual D D { get; protected set; } 
    public virtual string Name { get; protected set; } 
    public virtual string GFP => $"{D.GFP}/{Name}";  // Here I use D property that I think breaks LSP 
} 

public class C : L { 
    public C (D d, string name) { 
     D = d; 
     Name = name; 
    } 
} 

public class V : L { 
    public V (RA ra, string name) { 
     RA = ra; 
     Name = name; 
     D = ra.D; 
    } 
    public RA RA { get; private set; } 
    public override string GFP => $"{RA.GFP}/{Name}"; // Here I should override GFP to use RA instead of D 
} 

public class D : VOBase<D>, IGFP { 
    public D (U u, string name) { 
     U = u; 
     Name = name; 
    } 
    public U U { get; private set; } 
    public string Name { get; private set; } 
    public string GFP => $"{U.GFP}/{Name}"; 
} 

public class RA : VOBase<RA>, IGFP { 
    public RA (D d, string name) { 
     D = d; 
     Name = name; 
    } 
    public D D { get; private set; } 
    public string Name { get; private set; } 
    public string GFP => $"{D.GFP}/{Name}"; 
} 

Answer 1

Je suis sûr que tout ce que vous Sentir est pas vraiment décrit par cette question.

Mais laissez-moi tenter de le décomposer. Le premier D est seulement utilisé par deux autres classes. Aucun problème avec cela. Qu'est-ce qui différencie D des deux classes référençant une classe comme String? Donc, nous allons le retirer du diagramme:

+---+       +----+ 
| L |       | RA | 
+---+       +----+ 
    |    +---+   | 
inherit ----<----| V | --uses-->--+ 
    |  +---+ +---+ 
    +---<---| C | 
      +---+ 

Maintenant, RA n'est utilisé, pourquoi est-ce différent d'utiliser une classe comme String ou D, nous allons la supprimer du schéma:

+---+ 
| L | 
+---+ 
    |    +---+    
inherit ----<----| V | 
    |  +---+ +---+ 
    +---<---| C | 
      +---+ 

Nous avons maintenant un diagramme très simple qui ne montre aucun problème.

Donc, non, votre diagramme n'indique aucun anti-pattern. Mais cela ne veut pas dire que ce n'est pas un, juste que le diagramme ne contient pas assez d'informations. Je sais que vous avez essayé d'expliquer en anglais, mais l'anglais est ambigu. Ne voir qu'un exemple de code réel sur la façon dont ces classes interagissent permettrait aux gens d'identifier des anti-modèles ou des améliorations.