class BaseClass
{
  // это будут вызывать наследники с алгоритмом вычисления param "по умолчанию"
  public BaseClass(x, y, z) : this(x, y, z, GetParam(x, y, z)) {
  }

  // это будут вызывать наследники с собственным алгоритмом вычисления param
  protected BaseClass(x, y, z, int param) {
  }

  private static int GetParam(x, y, z) {
    // Вычисляем параметр по алгоритму для BaseClass
  }
}

class AncestorClass1 : BaseClass
{
  public AncestorClass(x, y, z) : base(x, y, z) // вычисление param "по-умолчанию"
  {
  }
}

class AncestorClass2 : BaseClass
{
  public AncestorClass(x, y, z) : base(x, y, z, GetParam(x, y, z)) // Собственный алгоритм
  {
    // Инициализация полей AncestorClass
  }

  private static int GetParam(x, y, z)
  {
    // Вычисляем параметры по алгоритму для AncestorClass
  }
}

public AncestorClass(...)
   : base(..., InitializeFields(...))
 {
 }

private ... InitializeFields(...)
{
  // Инициализация полей AncestorClass
}

interface IInitializable
{
  void Initialize();
}

class Base : IInitializable
{
  protected virtual void InitializableCore() {
    // Инициализация по-умолчанию
  }

  public void Initialize() {
    InitializableCore();
  }
}

class Derived : Base
{
  protected override void InitializableCore() {
    // Инициализация конкретного класса
  }
}

GA>Там, правда, можно вообще забыть вызвать унаследованный конструктор, но таких проблем за 15 лет программирования я не помню Зато порядком инициализации управляю как хочу, и не надо по два конструктора и лишней функции писать

class BaseClass
{
 public BaseClass(...)
 {
   int param = GetParam(...);
   // Здесь реализация одинакового для всех классов алгоритма,
   // в котором есть зависимость от param
 }

 protected virtual int GetParam(...)
 {
   // Вычисляем параметр по алгоритму для BaseClass
 }
}

class AncestorClass : BaseClass
{
 public AncestorClass(...)
   : base(...)
 {
   // Инициализация полей AncestorClass
 }

 protected override int GetParam(...)
 {
   // Вычисляем параметры по алгоритму для AncestorClass
 }
}

(данные)=>[SomeClass]=>(данные)=>[BaseClass]=>(данные)=>[GetParamMethod]=>(данные)=>[SomeClass]

(данные)=>[GetParamMethod]=>(данные2)=>[SomeClass]=>(данные2)=>[BaseClass]

(данные)=>[GetParamMethod]=>(данные2)=>[SomeClass]=>(данные2)=>[BaseClass]

class AncestorClass2 : BaseClass
{
  public AncestorClass(x, y, z) : base(x, y, z, GetParam(x, y, z)) // Собственный алгоритм
  {
    // Инициализация полей AncestorClass
  }

  private static int GetParam(x, y, z)
  {
    // Вычисляем параметры по алгоритму для AncestorClass
  }
}

function _ClassCreate(AClass: TClass; Alloc: Boolean): TObject;
asm
        { ->    EAX = pointer to VMT      }
        { <-    EAX = pointer to instance }
        PUSH    EDX
        PUSH    ECX
        PUSH    EBX
        TEST    DL,DL
        JL      @@noAlloc
        CALL    DWORD PTR [EAX] + VMTOFFSET TObject.NewInstance
@@noAlloc:
{$IFNDEF PC_MAPPED_EXCEPTIONS}
        XOR     EDX,EDX
        LEA     ECX,[ESP+16]
        MOV     EBX,FS:[EDX]
        MOV     [ECX].TExcFrame.next,EBX
        MOV     [ECX].TExcFrame.hEBP,EBP
        MOV     [ECX].TExcFrame.desc,offset @desc
        MOV     [ECX].TexcFrame.ConstructedObject,EAX   { trick: remember copy to instance }
        MOV     FS:[EDX],ECX
{$ENDIF}
        POP     EBX
        POP     ECX
        POP     EDX
        RET

{$IFNDEF PC_MAPPED_EXCEPTIONS}
@desc:
        JMP     _HandleAnyException

  {       destroy the object                                                      }

        MOV     EAX,[ESP+8+9*4]
        MOV     EAX,[EAX].TExcFrame.ConstructedObject
        TEST    EAX,EAX
        JE      @@skip
        MOV     ECX,[EAX]
        MOV     DL,$81
        PUSH    EAX
        CALL    DWORD PTR [ECX] + VMTOFFSET TObject.Destroy
        POP     EAX
        CALL    _ClassDestroy
@@skip:
  {       reraise the exception   }
        CALL    _RaiseAgain
{$ENDIF}
end;

class function TObject.NewInstance: TObject;
begin
  Result := InitInstance(_GetMem(InstanceSize));
end;

{ Virtual method table entries }

  vmtSelfPtr           = -76;
  vmtIntfTable         = -72;
  vmtAutoTable         = -68;
  vmtInitTable         = -64;
  vmtTypeInfo          = -60;
  vmtFieldTable        = -56;
  vmtMethodTable       = -52;
  vmtDynamicTable      = -48;
  vmtClassName         = -44;
  vmtInstanceSize      = -40;
  vmtParent            = -36;
  vmtSafeCallException = -32 deprecated;  // don't use these constants.
  vmtAfterConstruction = -28 deprecated;  // use VMTOFFSET in asm code instead
  vmtBeforeDestruction = -24 deprecated;
  vmtDispatch          = -20 deprecated;
  vmtDefaultHandler    = -16 deprecated;
  vmtNewInstance       = -12 deprecated;
  vmtFreeInstance      = -8 deprecated;
  vmtDestroy           = -4 deprecated;

  vmtQueryInterface    = 0 deprecated;
  vmtAddRef            = 4 deprecated;
  vmtRelease           = 8 deprecated;
  vmtCreateObject      = 12 deprecated;

class Base : IInitializable
{

void Create()
{}

  protected virtual void InitializableCore() {
    Create();  }

  public Base() {
    InitializableCore();
  }
}

class Derived : Base
{
  protected override void InitializableCore() {
    Create()
  }
new void Create()
{
..........
base.Create();

}

}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            var v = new Base();
            var v2 = new Derived();

            v = new Base(1,2,3);
            v2 = new Derived(1, 2, 3);

            Console.ReadKey();
        }
    }
    class Base
    {

        protected virtual void AfterCreate()
        {
            Console.WriteLine("AfterCreate");

        }

        protected void Create(int x, int y, int z)
        {
            Console.WriteLine("Base");
            Console.WriteLine("x = {0} y = {1} z = {2}", x, y, z);

        }

        protected void Create()
        {
            Console.WriteLine("Base без параметров");


        }

        protected virtual void InitializableCore(int x, int y, int z)
        {
            Create(x, y, z);
            AfterCreate();
        }

        protected virtual void InitializableCore()
        {
            Create();
            AfterCreate();
        }

        public Base(int x, int y, int z)
        {
            InitializableCore(x, y, z);
        }

        public Base()
        {
            InitializableCore();
        }
    }

    class Derived : Base
    {
        protected override void InitializableCore(int x, int y, int z)
        {
            Create(x, y, z);
            AfterCreate();
        }

        protected override void InitializableCore()
        {
            Create();
            AfterCreate();
        }
        protected new void Create(int x, int y, int z)
        {
            Console.WriteLine("Derived");
            Console.WriteLine("x = {0} y = {1} z = {2}", x, y, z);
            base.Create(z, y, x);

        }

        protected new void Create()
        {
            Console.WriteLine("Derived без параметров");
            base.Create();

        }

        public Derived()
            : base()
        { }

        public Derived(int x, int y, int z)
            : base(x, y, z)
        { }
    }

}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            var v = new Base();
            var v2 = new Derived();

            v = new Base(1,2,3);
            v2 = new Derived(1, 2, 3);

            Console.ReadKey();
        }
    }
    class Base
    {

        protected virtual void AfterCreate()
        {
            Console.WriteLine("AfterCreate");
            Console.WriteLine("======================================");

        }

        protected virtual void Create(int x, int y, int z)
        {
            Console.WriteLine("Base");
            Console.WriteLine("x = {0} y = {1} z = {2}", x, y, z);

        }

        protected virtual void Create()
        {
            Console.WriteLine("Base без параметров");


        }

       

        public Base(int x, int y, int z)
        {
            Create(x, y, z);
            AfterCreate();
        }

        public Base()
        {
            Create();
            AfterCreate();
        }
    }

    class Derived : Base
    {
        
        protected override void Create(int x, int y, int z)
        {
            Console.WriteLine("Derived");
            Console.WriteLine("x = {0} y = {1} z = {2}", x, y, z);
            base.Create(z, y, x);

        }

        protected override void Create()
        {
            Console.WriteLine("Derived без параметров");
            base.Create();

        }

        public Derived()
            : base()
        { }

        public Derived(int x, int y, int z)
            : base(x, y, z)
        { }
    }

}