类中的继承和类

Question

Here's some pseudo code to illustrate what I'm looking at.

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

I need to derive a class from Loader, and then override the Add method of the ItemsToLoad class inside it, and then call base.Execute(). In other words I want the Execute() method of my derived class to be exactly the same as that of Loader, but to use the overridden Add method of ItemsToLoad to to its work.

I suspect the neatest way to do this would be to remove ItemsToLoad from inside Loader, and make it abstract, correct?

If I couldn't do that, out of interest, what's the best solution?

Answer 1

If I understand your requirement, you have two responsabilities: executing something (which is always the same), and adding something (which differs).

I would do it much simpler, without inheritance and inner classes.

For the adding task, you define an interface:

public interface IItemAdder
{
    void Add();
}

And one ore more implementations:

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

Then, you have a Loader, in which you inject a specific instance of 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();
}

And so usage is:

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

This way everything is injected, can be replaced and mocked easily; and you clearly separate concerns.

Answer 2

Here is a suggestion (Syntax might not be correct though):

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

And here is how to use them;

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

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

Answer 3

You can inherit both classes and inject child sub-class object to its parent.

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

    }
}

And can start with

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

Answer 4

I need to derive a class from Loader, and then override the Add method of the ItemsToLoad class inside it, and then call base.Execute(). In other words I want the Execute() method of my derived class to be exactly the same as that of Loader, but to use the overridden Add method of ItemsToLoad to to its work.

You need to override Loader , not ItemsToLoad . You haven't shown the code that uses ItemsToLoad , so it's difficult to be specific - but at the very least, you would need to override the new ItemsToLoad to point to your subclass. Also, ItemsToLoad is private - meaning you can't use it except from within Loader . As it is now, you'd need a completely rewritten ItemsToLoad and to override every method in Loader that uses ItemsToLoad .

If you control the Loader class, the easiest changes would probably be to abstract out the creating of ItemsToLoad and open up ItemsToLoad so it can be subclassed. Something like:

public class Loader {
   private ItemsToLoad Items { get; set; }

   protected virtual ItemsToLoad CreateItemsToLoad() {
      return new ItemsToLoad();
   }

   protected class ItemsToLoad {
      public virtual void Add() {
      }
   }
}

public class MyOtherLoader : Loader {
   protected override ItemsToLoad CreateItemsToLoad() {
      return new MyOtherItemsToLoad();
   }

   private class MyOtherItemsToLoad : ItemsToLoad {
      public override void Add() {
      }
   }
}