C#

public abstract class MyBase
{
  public MyBase()
  {
    Initialize();
  }

  private void Initialize()
  {
    OnInitialize();
  }

  protected virtual void OnInitialize()
  {
  }
}

contains a call chain that results in a call to a virtual method defined by the class

DaveyM69 wrote:

The overridden method is purely setting instance fields unique to that class to
their initial values (these are not changed anywhere after instanciation - that
part of the derived classes is immutable) and returning initialization values
that are common to all derived classes to the base's constructor.

jschell wrote:

why would the base ctor care about child initialization values when all the base
ctor should be doing is initializing the base ctor

public abstract class Base
{
    private int commonValue1;
    private int commonValue2;
    private int id;

    protected Base(int id)
    {
        this.id = id;
        Initialize(out commonValue1, out commonValue2); // CA2214
    }

    public int CommonValue1
    {
        get { return commonValue1; }
    }
    public int CommonValue2
    {
        get { return commonValue2; }
    }
    public int Id
    {
        get { return id; }
    }

    protected abstract void Initialize(out int commonValue1, out int commonValue2);
}

public class ChildA : Base
{
    public ChildA(int id)
        : base(id)
    { }

    protected override void Initialize(out int commonValue1, out int commonValue2)
    {
        DataA data;
        NativeMethods.UnmanagedFunctionGetChildAData(Id, out data);
        commonValue1 = data.Value1;
        commonValue2 = data.Value2;
    }
}

public class ChildB : Base
{
    private int childBValue;

    public ChildB(int id)
        : base(id)
    { }

    public int ChildBValue { get { return childBValue; } }

    protected override void Initialize(out int commonValue1, out int commonValue2)
    {
        DataB data;
        NativeMethods.UnmanagedFunctionGetChildBData(Id, out data);
        commonValue1 = data.Value1;
        commonValue2 = data.Value2;
        childBValue = data.Value3;
    }
}

public class ChildC : Base
{
    private int childCValue1;
    private int childCValue2;

    public ChildC(int id)
        : base(id)
    { }

    public int ChildCValue1 { get { return childCValue1; } }
    public int ChildCValue2 { get { return childCValue2; } }

    protected override void Initialize(out int commonValue1, out int commonValue2)
    {
        DataC data;
        NativeMethods.UnmanagedFunctionGetChildCData(Id, out data);
        commonValue1 = data.Value1;
        commonValue2 = data.Value2;
        childCValue1 = data.Value3;
        childCValue2 = data.Value4;
    }
}

[StructLayout(LayoutKind.Sequential)]
internal struct DataA
{
    private int value1;
    private int value2;

    public int Value1 { get { return value1; } }
    public int Value2 { get { return value2; } }
}

[StructLayout(LayoutKind.Sequential)]
internal struct DataB
{
    private int value1;
    private int value2;
    private int value3;

    public int Value1 { get { return value1; } }
    public int Value2 { get { return value2; } }
    public int Value3 { get { return value3; } }
}

[StructLayout(LayoutKind.Sequential)]
internal struct DataC
{
    private int value1;
    private int value2;
    private int value3;
    private int value4;

    public int Value1 { get { return value1; } }
    public int Value2 { get { return value2; } }
    public int Value3 { get { return value3; } }
    public int Value4 { get { return value4; } }
}

internal static class NativeMethods
{
    // this methods are just simulating the unmanaged functions that retrieve filled DataA/DataB/DataC
    public static void UnmanagedFunctionGetChildAData(int id, out DataA data)
    {
        data = new DataA();
    }
    public static void UnmanagedFunctionGetChildBData(int id, out DataB data)
    {
        data = new DataB();
    }
    public static void UnmanagedFunctionGetChildCData(int id, out DataC data)
    {
        data = new DataC();
    }
}

DaveyM69 wrote:

Perhaps this code will make it clearer...

jschell wrote:

based members protected

jschell wrote:

protected setter for those members

DaveyM69 wrote:

Non private fields are generally not considered a great idea.

DaveyM69 wrote:

it implies to inheriting classes that the fields that are protected by the property can be changed after initialization