Quelle est la meilleure approche pour concevoir cette classe abstraite? (Partie 2)

Question

J'ai une classe abstraite appelée Locataire et Client. Le locataire dans ce cas est comme le propriétaire de l'application pour le modèle d'application multi-locataire.

La relation entre ces deux classes est relation de plusieurs à une. Avec la conception OO

public abstract class Tenant 
{ 
    protected Int32 id; 
    protected String name; 
    public Int32 ID { get; set; } 
    public String Name { get; set; } 
    public abstract bool Add(); 
    public abstract bool Update(); 
    public abstract bool Delete(); 
    public abstract List<Tenant> Get(); 
} 

public class ApplicationTenant: Tenant 
{ 
    public ApplicationTenant() { } 
    public override Int32 ID 
    { 
    get { return id; }  
    set { id = value; } 
    } 
    public override String Name 
    {  
    get { return name; }  
    set { name= value; } 
    } 


    public override List<Tenant> Get() 
    { 
    ... 
    } 
} 

public abstract class Customer 
{ 
    protected Int32 id; 
    protected String name; 
    protected Tenant tenant; 
    public Int32 ID { get; set; } 
    public String Name { get; set; } 
    public Tenant Tenant { get; set; } 
    public abstract bool Add(); 
    public abstract bool Update(); 
    public abstract bool Delete(); 
    public abstract List<Customer> Get(); 
} 

public class CorporateCustomer : Customer 
{ 
    public CorporateCustomer() { } 
    public override Int64 ID 
    {  
    get { return id; }  
    set { id = value; } 
    } 

    public override String Name 
    {  
    get { return name; }  
    set { name= value; } 
    } 

    public override Tenant Tenant 
    {  
    get { return tenant; }  
    set { tenant= value; } 
    } 

    public override List<Customer> Get() 
    { 
    ... 
    } 

    ... 
} 

ci-dessus, nous savons que la méthode des besoins List<Tenant> Get() à overrided.

mais la question sont:

1) La valeur de retour de la commande Get() dans le CorporateCustomer va toujours être List<CorporateCustomer>. Il meeans que je dois passer outre List<Tenant> Get() sans être mise en œuvre et créer une autre méthode suivante

2) Si je remplace de toute façon cette méthode ci-dessus et sur le retun je viens de la lancer ... ça ne marchera pas de toute façon. ? !!? ACESI coulée à List<CorporateCustomer> de List<Customer>

3) La propriété ci-dessous:

public override Tenant Tenant 
    {  
    get { return tenant; }  
    set { tenant= value; } 
    } 

signifie encore une fois, je dois passer outre ce BUTI ne pas que je vraiment utilisé cette cause le CorporateCustomer va toujours être utilisé à la place du ApplicationTenant comme retour PAS locataire.

public CorporateTenant Tenant 
    {  
    get { return corprateTenant; }  
    set { corprateTenant= value; } 
    } 

Alors, est-ce le bon design? Parce que c'est un peu le gaspillage de l'abstraction.

Certaines personnes suggèrent d'utiliser Generic abstract class à la place, mais je ne suis pas sûr que cela puisse aider de toute façon.

J'ai apprécié vos commentaires.

Merci

Answer 1

Le concept d'abstraction peut vous aider à faire votre code modulaire, il aide les clients de votre modèle pour définir l'abstraction droit dans leurs conceptions et évitant ainsi la répétition de la logique je vais essayer d'élaborer à ce sujet,

Envisager une classe appelée CorporateTenantManager qui dit traite avec la gestion de la société locataire. Cette classe sera 'aware' de la présence de classes CorporateTenant et 'CorporateCustomer' et traitera donc les choses en Corporate *.
Cependant, considérons maintenant une classe qui est responsable de l'authentification du client, par exemple, cette classe peut ne pas être intéressée à savoir quel type de client elle est et traitera donc en Customer seulement.

Vous n'avez donc pas besoin d'ajouter des accesseurs-setters pour chaque classe de béton. Dans le cas d'un getter-setters, le client de la classe sait à quoi s'attendre donc même si le type de retour est un type abstrait, le client va le lancer dans la classe concrète qu'il attend.

Answer 2

Il semble que vous ayez besoin de séparer vos préoccupations. La classe des locataires devrait être responsable de stocker des données sur un seul locataire ou de faire quelque chose à un seul locataire.Je ne comprends pas vraiment pourquoi ou comment vous retourneriez une liste de locataires à partir d'un seul objet locataire. Ou ce que la méthode Add est supposée faire. Si vous voulez stocker un groupe de locataires, vous devriez utiliser une sorte de collection.

Si vous n'avez pas mise en œuvre spécifique applicable dans les classes qui hériteront de votre classe de base, vous êtes probablement mieux à l'aide d'une interface au lieu d'une classe abstraite.

public interface ITenant 
{ 
    int ID { get; set; } 
    string Name { get; set; } 
} 

public interface ICustomer 
{ 
    int ID { get; set; } 
    string Name { get; set; } 
    ITenant Tenant { get; set; } 
}