Using base classes when inheriting

Question

How do I pull functionality from a base class that returns the base type, into an inherited class?

I have a base class Chapter, and a child class EnhancedChapter that adds some functionality to Chapter.

Unfortunately, one base class method returns the class type. I can access this method in the child class, but it since it returns the base type, and not the child type, I'm having trouble bringing its functionality into the child class.

Here's the base class (Page is implemented elsewhere, you'll get the picture):

class Chapter
{
    public List<Page> pages;

    public Chapter()
    {
        pages = new List<Page>();
    }

    public Chapter CalculatedChapter(DateTime date)
    {
        pages.ForEach(p => p.CalculatedPage(date));
        return this;
    }
}

Here's the child class:

class EnhancedChapter : Chapter
{
    public int? PageCount()
    {
        if (pages != null) return pages.Count; else return null;
    }
}

Now, when I want to use CalculatedChapter() in a the child class, I run into issues:

EnhancedChapter enhancedChapter;
// won't work, returns Chapter not EnhancedChapter
enhancedChapter = new EnhancedChapter().CalculatedChapter(DateTime.Now);

Some options I thought of, but that didn't fit well with me: I could do a cast here, but that seems prone to errors down the road. I also thought about somehow feeding the result of CalculatedChapter() into the child class constructor, but can't figure out how to do that.

Answer 1

I think this will do it...

abstract class ChapterBase<T> where T : ChapterBase<T>
{
    public List<Page> pages;

    public ChapterBase()
    {
        pages = new List<Page>();
    }

    public T CalculatedChapter(DateTime date)
    {
        pages.ForEach(p => p.CalculatedPage(date));
        return (T)this;
    }

}

class Chapter :ChapterBase<Chapter>
{
}

class EnhancedChapter : ChapterBase<EnhancedChapter>
{
    public int? PageCount()
    {
        if (pages != null) return pages.Count; else return null;
    }
}

Answer 2

Well if you really need to do it like this, after considering different design options, you could define hiding method in EnhancedChapter:

class EnhancedChapter : Chapter
{
    public int? PageCount()
    {
        if (pages != null) return pages.Count; else return null;
    }

    public new EnhancedChapter CalculatedChapter(DateTime date) {
        return (EnhancedChapter)base.CalculatedChapter(date);
    }
}

Then if you use it through EnhancedChapter reference - this method would be called, otherwise - base one.

Answer 3

In such a case you can use the new keyword to hide the method of the base implementation and provide a modified version. In that new method you then call the base method and cast its result to EnhancedChapter.

So for your provided example you can modify your EnhancedChapter class like this:

class EnhancedChapter : Chapter {
    public int? PageCount() {
        if (pages != null) return pages.Count; else return null;
    }

    // Note the "new" keyword, hiding the base method implementation, and the changed return type
    public new EnhancedChapter CalculatedChapter(DateTime date) {
        // Just call the method on base and cast the result
        return (EnhancedChapter)base.CalculatedChapter(date);
    }
}

---

edit

Your concerns about the casting are not necessary in this case. This approach basically just makes working with the derived types more comfortable.

When you'll have other types derived from Chapter and use the CalculatedChapter() method, then there are 2 options:

1. When the type does not have its own new CalculatedChapter() method then the base method implementation is called returning a Chapter
2. When the type has its own new CalculatedChapter() method then that method is called

Even if you derive a new class from EnhancedChapter it will still only either use the base implementation (in that case of EnhancedChapter) or can provide its own implementation, hiding the base implementation.

But it's worth noting that when you're using the derived types in fields typed as Chapter then the new CalculatedChapter() method is NOT called (since you're working with the Chapter type). See the following example:

// Create EnhancedChapter            
EnhancedChapter chapEnhanced = new EnhancedChapter();

// Store the enhanced chapter as Chapter
Chapter chapEnhancedAsChapter = chapEnhanced;

// This calls the "new" method on EnhancedChapter
chapEnhanced.CalculatedChapter(DateTime.Now);

// This calls the base method implementation directly
chapEnhancedAsChapter.CalculatedChapter(DateTime.Now);

In that case no cast is made on the second call, but this also means that you cannot do any state-changing operations specific to the derived type in that methods. For example when adding a new property to EnhancedChapter, then you should not update that property in the new CalculatedChapter() method since you cannot ensure that this method is actually used.

So in the end this approach will only work when using it to increase the comfort when working with the derived types, but you cannot use it when you're actually changing the implementation details within these different methods.