C # pregunta básica de polimorfismo

Question

No estoy seguro de que sea realmente un "polimorfismo" pregunta pero de todos modos ... Entonces tengo una clase abstracta y otras 2 clases que heredan de ella.

Algunos códigos de la clase base tienen una variable que sería diferente entre clases que extiende la clase base.

¿Cuál es la mejor manera de hacer eso? Anular a " obtener " ¿método? Cambie un poco la arquitectura para llamar a una función desde la clase base a la clase extendida que pasaría el valor ...

Aquí hay un ejemplo (no se compilará, solo un pequeño ejemplo de cómo lo hice):

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

Así lo hice, pero no se siente realmente claro y fácil de mantener IMO.

Cualquier idea o comentario bienvenido

Answer 1

Probablemente optaría por algo como esto:

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

Prefiera la composición sobre la herencia.

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

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

}

Si esta es la única dimensión de variación entre sus subclases, ya no hay necesidad de herencia aquí; solo establezca el ItemListGetter correcto según sea necesario.

Answer 3

Probablemente elegiría el siguiente enfoque:

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

Esto mantiene la funcionalidad protegida interna (getAllItems) separada del método / propiedad expuesto públicamente, y también significa que todavía está disponible para cualquier clase que herede de NewClass.

¡Cambié su interfaz y la expuse como una propiedad puramente de cabeza de cerdo! Y fiesta en caso de que no supieras que se podría hacer ...

Answer 4

¿no está seguro de que es la respuesta correcta, pero podría tener una variable protegida de clase base que establezca en las clases heredadas durante la inicialización?

por ejemplo:

class test
{
    protected string listName;

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

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

Answer 5

Creo que tendría más sentido implementar un tercer componente:

    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 realmente quieres hacer la herencia, entonces optaría por ctacke's solución.

Generalmente, sin embargo, su problema no parece resolverse con la herencia. La herencia solo debe usarse para proporcionar un comportamiento especializado. En su caso, sin embargo, parece ser más un problema de configuración. Lo que significa que debe proporcionar una propiedad (es decir, el nombre de la lista) que configure desde el exterior, sin necesidad de subclases.