C # Grund Polymorphismus Frage

Question

Ich bin mir nicht sicher, ob es wirklich eine „Polymorphismus“ Frage, aber trotzdem ... Also ich habe eine abstrakte Klasse und zwei andere Klassen, die von ihm erben.

Einige Code von der Basisklasse haben eine Variable, die unterschiedlich zwischen den Klassen sein würden, die die Basisklasse erweitert.

Was ist der beste Weg, das zu tun? Überschreiben Sie eine Methode „get“? Ändern Sie die Architektur ein wenig eine Funktion von der Basis classe auf die erweiterte Klasse zu nennen, die den Wert passieren würde ...

Hier ist ein Beispiel (es wird nicht kompiliert, nur ein kleines Beispiel dafür, wie ich tat es):

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");
 }
}

Das ist, wie ich es tat, aber es fühlt sich nicht wirklich klar und einfach IMO zu halten.

Jede Idee oder Kommentar willkommen!

Answer 1

ich wahrscheinlich für so etwas entscheiden würde:

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

Bevorzugen Komposition der Vererbung.

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

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

}

Wenn dies die einzige Dimension der Variation zwischen den Unterklassen ist, gibt es keine Notwendigkeit mehr für die Vererbung hier; schaffen genau den richtigen ItemListGetter nach Bedarf.

Answer 3

ich wahrscheinlich für den folgenden Ansatz gehen würde:

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");
        }
    }
}

Dies hält die interne geschützte Funktionalität (getAllItems) getrennt von der öffentlich ausgesetzten Methode / Eigenschaft, und das bedeutet auch, dass seine noch zu irgendwelchen Klassen zur Verfügung, die von NewClass erben.

Ich habe Ihre Schnittstelle geändert und exponierte sie als Eigenschaft rein aus Dickköpfigkeit! Und Partei nur, wenn Sie weiß nicht, es getan werden könnte ...

Answer 4

nicht sicher, es ist die richtige Antwort, aber man konnte eine Basisklasse geschützt Variable, die Sie in den vererbten Klassen während der Initialisierung gesetzt?

Beispiel:

class test
{
    protected string listName;

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

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

Answer 5

Ich denke, es würde mehr Sinn macht eine dritte Komponente der Umsetzung:

    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

Wenn Sie wirklich das Erbe tun wollen, dann würde ich für ctacke OPT Lösung.

Generell aber Ihr Problem scheint nicht mit Vererbung zu lösen. Vererbung sollte nur verwendet werden, spezielles Verhalten zu schaffen. In Ihrem Fall jedoch scheint es ein Konfigurationsproblem zu sein. Das heißt, Sie eine Eigenschaft zur Verfügung stellen sollte (das heißt der Listenname), die Sie von außen konfigurieren, ohne dass für die Unterklassen.