从抽象类构造函数中调用抽象方法

Question

I would like to ask what are the risks of having something as follows:

abstract public class HtmlTemplateBuilder
{
    HtmlSource source;

    protected HtmlTemplateBuilder()
    {
        LoadTemplates();
    }

    public abstract void LoadTemplates();
}

The risk is if a derived class derives from the derived class:

DerivedClass2 -> #DerivedClass1 -> HtmlTemplateBuilder

This can be solved by sealing #DerviedClass1, but are there any more risks or better practices for implementing this functionality?

Thanks

Answer 1

Have a look at this link which explains the perils with simple easy to understand examples

https://blogs.msmvps.com/peterritchie/2012/04/25/virtual-method-call-from-constructor-what-could-go-wrong/

I would remove the call to LoadTemplates from constructor and call Initialise on it when the templates actually need to be loaded and used.

abstract public class HtmlTemplateBuilder
{
    HtmlSource source;
    object locker = new object();
    private bool initialised;

    protected HtmlTemplateBuilder()
    {
    }

    protected void Initialise()
    {
        lock (locker)
        {
            if(initialised)
            {
                LoadTemplates();
                initialised = true;
            }
        }
    }

    public abstract void LoadTemplates();
}

Answer 2

The situation in which this pattern bit me is as follows: at some later stage you want to add a specialized HtmlTemplateBuilder , which can load different templates based on some criteria unknown to the class itself (maybe you decide you want some cool templates on a specific day of the year). That is:

public class SpecialHtmlTemplateBuilder : HtmlTemplateBuilder
{
    private bool someCondition;

    public override void LoadTemplates()
    {
        if (someCondition)
        {
            LoadTemplatesSet1();
        }
        else
        {
            LoadTemplatesSet2();
        }
    }
}

But how are you going to pass someCondition to the class? The following won't work:

public class SpecialHtmlTemplateBuilder : HtmlTemplateBuilder
{
    private bool someCondition;

    public SpecialHtmlTemplateBuilder (bool someCondition)
    {
        this.someCondition = someCondition;
    }

    // ...
}

because the assignment of this.someCondition will be done after calling the base constructor, ie, after LoadTemplates() is called. Note that sealing derived classes does not solve this problem.

The way to solve this is as @Rahul Misra described: add an explicit Initialize method and call that after the constructor.