Question

这里有一些伪代码来说明我在看什么。

public class Loader
{
    public Execute()
    {
       var currentPage = new ItemPageDocumentBuilder();
       while(reader.Read())
       {
           currentPage.Add(reader.XmlDoc);
       }
    }

    private class ItemsToLoad
    {
        private XmlDocument _page
        public void Add(XmlElement itemelement)
        {
            _page.DocumentElement.AppendChild(itemElement);
        }
    }
}

我需要从Loader派生一个类，然后覆盖其中ItemsToLoad类的Add方法，然后调用base.Execute（）。换句话说，我希望派生类的Execute（）方法与Loader的方法完全相同，但是要使用重写的ItemsToLoad的Add方法来实现它的工作。

我怀疑最好的方法是从Loader中删除ItemsToLoad，并使其抽象，正确吗？

如果我不能这样做，出于兴趣，什么是最好的解决方案？

Answer 1

如果我理解你的要求，你有两个责任：执行某些事情（总是相同的），并添加一些东西（不同的）。

我会更简单，没有继承和内部类。

对于添加任务，您可以定义一个接口：

public interface IItemAdder
{
    void Add();
}

还有一个或多个实施：

public class ItemAdder1 : IItemAdder
{
    public void Add()
    {            
         // specific implementation here
    }
}

然后，你有一个Loader，你可以在其中注入item adder的特定实例：

public class Loader : ILoader
{
    private IItemAdder _itemAdder;
    public Loader(IItemAdder itemAdder)
    {
        _itemAdder = itemAdder;
    }
    public void Execute()
    {
        // use injected item adder to do work
        _itemAdder.Add();
    }       
}

public interface ILoader
{
    void Execute();
}

所以用法是：

var loader = new Loader(new ItemAdder1());
loader.Execute();

这样一切都被注入，可以轻易替换和嘲笑;并且你明确区分了问题。

Answer 2

这是一个建议（虽然语法可能不正确）：

public class Loader
{
    ItemsToLoad item;
    public Loader(ItemsToLoad item) {
      this.item = item;
    }

    public Execute()
    {
       // do things using item like item.add();
    }
}

interface ItemsToLoad
{
    void add();
}

class ItemsToLoad1: ItemsToLoad
{
    void add(){
        // implementation
    }
}

class ItemsToLoad2: ItemsToLoad
{
    void add(){
        // implementation
    }
}

以下是如何使用它们;

ItemsToLoad item;
if (some condition) {
   item = new ItemsToLoad1()
} else {
   item = new ItemsToLoad2()
}

Loader loader = new Loader(item);
loader.execute();

Answer 3

您可以继承这两个类并将子子类对象注入其父级。

class Loader
    {

        public void Execute(ItemsToLoad argObj)
        {
            if(argObj == null)
                argObj = new ItemsToLoad();

            argObj.Add(19);
        }

        public class ItemsToLoad
        {
            public virtual void Add(int a)
            {
                Console.WriteLine("Reached ItemsToLoad.");
            }
        }
    }

class ChildLoader:Loader
    {
        public void Execute(ItemsToLoad argObjLoader)
        {
            if (argObjLoader == null)
                argObjLoader = new ChildItemsToLoad();

            base.Execute(argObjLoader);
    }

    class ChildItemsToLoad : Loader.ItemsToLoad
    {

        public override void Add(int b)
        {
            Console.WriteLine("Reached ChildItemsToLoad.");
        }

    }
}

可以从

开始

ChildLoader obj999 = new ChildLoader();
obj999.Execute(null);

Answer 4

我需要从Loader派生一个类，然后覆盖其中ItemsToLoad类的Add方法，然后调用base.Execute（）。换句话说，我希望派生类的Execute（）方法与Loader的方法完全相同，但是要使用重写的ItemsToLoad的Add方法来实现它的工作。

您需要覆盖Loader，而不是ItemsToLoad。您没有显示使用ItemsToLoad的代码，因此很难具体 - 但至少，您需要覆盖new ItemsToLoad以指向您的子类。此外，ItemsToLoad是私有的 - 这意味着除了Loader之外，您无法使用它。就像现在一样，您需要完全重写ItemsToLoad并覆盖使用Loader的{{1}}中的每个方法。

如果您控制ItemsToLoad类，最简单的更改可能是抽象出Loader的创建并打开ItemsToLoad，以便它可以被子类化。类似的东西：

ItemsToLoad

类中的继承和类

4 个答案: