Question de base sur le polymorphisme C #

Question

Je ne suis pas sûr que ce soit vraiment un "polymorphisme". question mais de toute façon ... J'ai donc une classe abstraite et 2 autres classes qui en héritent.

Certains codes de la classe de base ont une variable qui serait différente d’une classe à l’autre.

Quelle est la meilleure façon de faire cela? Ignorer un " obtenir " méthode? Modifiez un peu l’architecture pour appeler une fonction de la classe de base à la classe étendue qui passerait la valeur ...

Voici un exemple (il ne compilera pas, juste un petit exemple sur la façon dont je l'ai fait):

public abstract class BaseAbstract class {

  ... some code ....

  // Here "listName" would change depending on the extending class
  protected List<Items> getAllItems(String listName) {

    Web.getList(listName);

    ... some code ...

  }

  protected abstract List<Items> getAllItems();

}

public class NewClass : BaseAbstract {
 protected override void getAllItems() {
    return getAllItems("ListNameOfNewClass");
 }
}

C'est ce que j'ai fait, mais je ne me sens pas très clair et facile de maintenir l'OMI.

Toute idée ou commentaire est le bienvenu!

Answer 1

J'opterais probablement pour quelque chose comme ceci:

public abstract class Base
{
    protected abstract string ListName { get; }
    public List<Item> GetItems()
    {
        return Web.GetList(ListName);
    }
}

public class Child : Base
{
    protected override string ListName
    {
        get { return "MyListName"; }
    }
}

Answer 2

Préférer la composition à l'héritage.

public class Base {
  private ItemListGetter itemListGetter; // assignment/initialization is up to you

  private List<Items> getAllItems() {  // this can now be inlined
    return itemListGetter.getList();
  }

}

S'il s'agit de la seule dimension de variation entre vos sous-classes, l'héritage n'est plus nécessaire ici; juste établir le bon ItemListGetter au besoin.

Answer 3

Je choisirais probablement l'approche suivante:

public abstract class Base
{
    protected List<Items> getAllItems(String listName) 
    {
        // Implementation
    }

    public abstract List<Items> Items
    {
        get;
    }
}

public class NewClass : Base
{
    public override List<Items> Items
    {
        get
        {
            return base.getAllItems("ListNameOfNewClass");
        }
    }
}

Ceci conserve la fonctionnalité protégée interne (getAllItems) séparément de la méthode / propriété exposée publiquement, et signifie également qu'elle est toujours disponible pour toutes les classes qui héritent de NewClass.

J'ai changé votre interface et l'exposée comme une propriété purement dépourvue de tête de cochon! Et faire la fête au cas où vous ne le sauriez pas, cela pourrait être fait ...

Answer 4

Vous n'êtes pas sûr que ce soit la bonne réponse, mais vous pourriez avoir une variable protégée de classe de base que vous avez définie dans les classes héritées lors de l'initialisation?

par exemple:

class test
{
    protected string listName;

    protected void getAllItems() 
    {
        return getAllItems(listName);
    }
}

class test2 : test
{
    public test2()
    {
        base.listName = "MyUniqueList";
    }
}

Answer 5

Je pense qu'il serait plus logique de mettre en œuvre un troisième composant:

    public abstract class BaseClass {

        protected abstract IList<Item> getAllItems();
    }

    public class SubClass : BaseClass 
    {
        IItemsProvider itemsProvider;

        protected override IList<Item> getAllItems() 
        {
            return itemsProvider.getAllItems("filter");
        }
    }

    public interface IItemsProvider
    {
        IList<Item> getAllItems(string name);
    }

Answer 6

Si vous voulez vraiment faire l'héritage, je choisirais alors de ctacke's solution.

En règle générale, votre problème ne semble pas être résolu par héritage. L'héritage devrait juste être utilisé pour fournir un comportement spécialisé. Dans votre cas, cependant, cela semble être davantage un problème de configuration. Cela signifie que vous devez fournir une propriété (c'est-à-dire le nom de liste) que vous configurez de l'extérieur, sans qu'il soit nécessaire de sous-classer.