C#基本多态性问题

我不确定这是否真的是一个“多态性”问题，但无论如何。。。 所以我有一个抽象类和另外两个继承自它的类

基类中的某些代码具有一个变量，该变量在扩展基类的类之间可能有所不同

最好的方法是什么？重写“get”方法？稍微修改一下架构，将一个函数从基类调用到将传递值的扩展类

这里有一个例子（它不会编译，只是一个关于我是如何编译的小例子）：

公共抽象类BaseAbstract类{
…一些代码。。。。
//这里的“listName”将根据扩展类的不同而变化
受保护列表getAllItems（字符串listName）{
getList（listName）；
…一些代码。。。
}
受保护的抽象列表getAllItems（）；
}
公共类NewClass:BaseAbstract{
受保护的覆盖无效getAllItems（）{
返回getAllItems（“新类的列表名”）；
}
}

我就是这样做的，但是我觉得不太清楚，也不容易维护

---

任何想法或意见欢迎

不确定答案是否正确，但可以在初始化期间在继承的类中设置基类保护变量

例如：

---

不确定答案是否正确，但可以在初始化期间在继承的类中设置一个基类保护变量

例如：

---

我可能会选择这样的方式：

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

公共抽象类基类
{
受保护的抽象字符串ListName{get；}
公共列表GetItems（）
{
返回Web.GetList（ListName）；
}
}
公共类子类：基
{
受保护的重写字符串列表名
{
获取{返回“MyListName”；}
}
}

我可能会选择这样的方式：

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

公共抽象类基类
{
受保护的抽象字符串ListName{get；}
公共列表GetItems（）
{
返回Web.GetList（ListName）；
}
}
公共类子类：基
{
受保护的重写字符串列表名
{
获取{返回“MyListName”；}
}
}

我可能会选择以下方法：

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

公共抽象类基类
{
受保护列表getAllItems（字符串listName）
{
//实施
}
公开摘要清单项目
{
得到；
}
}
公共类NewClass:Base
{
公共覆盖列表项
{
得到
{
return base.getAllItems（“新类的列表名”）；
}
}
}

这使内部保护功能（getAllItems）与公开的方法/属性保持分离，也意味着它仍然可用于从NewClass继承的任何类

---

我改变了你的界面，并将其公开为一个纯粹出于愚蠢的属性！如果你不知道这是可以做到的，我可能会选择以下方法：

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

公共抽象类基类
{
受保护列表getAllItems（字符串listName）
{
//实施
}
公开摘要清单项目
{
得到；
}
}
公共类NewClass:Base
{
公共覆盖列表项
{
得到
{
return base.getAllItems（“新类的列表名”）；
}
}
}

这使内部保护功能（getAllItems）与公开的方法/属性保持分离，也意味着它仍然可用于从NewClass继承的任何类

---

我改变了你的界面，并将其公开为一个纯粹出于愚蠢的属性！如果你不知道可以这样做的话，我想实施第三个组件会更有意义：

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

公共抽象类基类{
受保护的抽象IList getAllItems（）；
}
公共类子类：基类
{
项目供应商项目供应商；
受保护的覆盖IList getAllItems（）
{
returnitemsProvider.getAllItems（“过滤器”）；
}
}
公共接口IItemsProvider
{
IList getAllItems（字符串名称）；
}

我认为实现第三个组件更有意义：

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

公共抽象类基类{
受保护的抽象IList getAllItems（）；
}
公共类子类：基类
{
项目供应商项目供应商；
受保护的覆盖IList getAllItems（）
{
returnitemsProvider.getAllItems（“过滤器”）；
}
}
公共接口IItemsProvider
{
IList getAllItems（字符串名称）；
}

公共类基{
private ItemListGetter ItemListGetter；//分配/初始化由您决定
私有列表getAllItems（）{//现在可以内联
返回itemListGetter.getList（）；
}
}

如果这是子类之间变化的唯一维度，那么这里就不再需要继承；只要根据需要建立正确的ItemListGetter即可。

公共类基{
private ItemListGetter ItemListGetter；//分配/初始化由您决定
私有列表getAllItems（）{//现在可以内联
返回itemListGetter.getList（）；
}
}

---

如果这是子类之间变化的唯一维度，那么这里就不再需要继承；只要根据需要建立正确的ItemListGetter。

如果您真的想继承，那么我会选择解决方案

---

然而，一般来说，您的问题似乎并没有通过继承得到解决。继承应该只用于提供专门的行为。然而，在您的情况下，这似乎更像是一个配置问题。这意味着您应该提供一个从外部配置的属性（即列表名），而不需要子类化。

如果您真的想进行继承，那么我会选择解决方案

然而，一般来说，您的问题似乎并没有通过继承得到解决。继承应该只用于