type
  TBaseObj = class;
  TBaseObjClass = class of TBaseObj;
  
  TMyObj1 = class(TBaseObj)
  end;

  TMyObj2 = class(TBaseObj)
  end;
  


procedure xxx1;
begin
  xxx2(TMyObj1);
end;

procedure xxx2(obj_class: TBaseObjClass);
var
  Obj: TBaseObj;
begin
  Obj := obj_class.Create;
  ....
end;

using System;

public interface IFruit
{
    void Eat();
}

public class Apple : IFruit
{
    public void Eat()
    {
        Console.WriteLine("Вкусное яблоко!");
    }
}

public class Pear : IFruit
{
    public void Eat()
    {
        Console.WriteLine("Вкусная груша!");
    }
}
public class Program
{
    public static void Main()
    {
        Type[] fruitTypes = new Type[]{typeof(Apple), typeof(Pear)};
        foreach(Type fruitType in fruitTypes)
        {
            IFruit fruit = CreateFruit(fruitType);
            fruit.Eat();
        }
    }
    
    public static IFruit CreateFruit(Type ofThisType)
    {
        return (IFruit) Activator.CreateInstance(ofThisType);
    }
}

            Type t = typeof(System.Text.StringBuilder);
            System.Reflection.ConstructorInfo ci = t.GetConstructor(Type.EmptyTypes); // конструктор без параметров
            object o = ci.Invoke(null);  // вызов конструктора

            Console.WriteLine(o.GetType());

J>type
J>  TBaseObj = class;
J>  TBaseObjClass = class of TBaseObj;
  
J>  TMyObj1 = class(TBaseObj)
J>  end;

J>  TMyObj2 = class(TBaseObj)
J>  end;
  


J>procedure xxx1;
J>begin
J>  xxx2(TMyObj1);
J>end;

J>procedure xxx2(obj_class: TBaseObjClass);
J>var
J>  Obj: TBaseObj;
J>begin
J>  Obj := obj_class.Create;
J>  ....
J>end;
J>

class BaseObj {}
class MyObj1: BaseObj {}
class MyObj2: BaseObj {}

class Program
{
    void xxx1()
    {
        xxx2(typeof(MyObj1));
    }
    
    void xxx2(Type objType)
    {
        BaseObj obj = (BaseObj)Activator.CreateInstance(objType);
    }
}

class Program
{
    void xxx1()
    {
        xxx2(typeof(MyObj1));
    }
    
    void xxx2<T>() where T: BaseObj
    {
        BaseObj obj = Activator.CreateInstance<T>();
    }
}

            Type t = typeof(System.Text.StringBuilder);
V>            System.Reflection.ConstructorInfo ci = t.GetConstructor(Type.EmptyTypes); // конструктор без параметров
V>            object o = ci.Invoke(null);  // вызов конструктора

V>            Console.WriteLine(o.GetType());
V>

var o: class of TMyObj;

class Obj1
{
    public Obj1(int x);
}

class Obj2 : Obj1
{
}
...
Obj2 obj = new Obj2(10);

J>class Obj1
J>{
J>    public Obj1(int x);
J>}

J>class Obj2 : Obj1
J>{
J>}
J>...
J>Obj2 obj = new Obj2(10);
J>

17.10.1 Constructor initializers
All instance constructors (except those for class object) implicitly include an invocation of another
instance constructor immediately before the constructor-body. The constructor to implicitly invoke is
determined by the constructor-initializer:

• An instance constructor initializer of the form base(argument-listopt) causes an instance constructor
from the direct base class to be invoked. That constructor is selected using argument-list and the
overload resolution rules of §14.4.2. The set of candidate instance constructors consists of all accessible
instance constructors declared in the direct base class, or the default constructor (§17.10.4), if no
instance constructors are declared in the direct base class. If this set is empty, or if a single best instance
constructor cannot be identified, a compile-time error occurs.

...
<skipped>
...
If an instance constructor has no constructor initializer, a constructor initializer of the form base() is
implicitly provided. [Note: Thus, an instance constructor declaration of the form

C(…) {…}

is exactly equivalent to

C(…): base() {…}

end note]

Inheritance means that a class implicitly contains all members of its direct base class, except for the instance constructors, destructors and static constructors of the base class. (MSDN)

class Obj1
{
    protected int _x;
    public Obj1(int x)
    {
        _x = x;
    }
}

class Obj2 : Obj1
{
    public Obj2(int x) : base(x)
    {
    }
}

J>>var o: class of TMyObj;
J>>

public class Base
{
    public Base(int x)
    {
    ...
    }
}

public class Child1 : Base
{
    public Child1(int x) : base (x)
    {
    }
}
  
public class Child2 : Base
{
    public Child2(int x) : base (x)
    {
    }
}
  
public class Child3 : Base
{
    public Child3(int x) : base (x)
    {
    }
}

public string xxx(Base class_type)
{
    Base obj = class_type(10);
    obj.GetType().ToString();
}

    xxx(Child1);
    xxx(Child2);
    xxx(Child3);

using System;

public class Base
{
    protected int _x;
    public Base(int x)
    {
        _x = x;
    }
    public void GetX()
    {
        Console.WriteLine(_x);
    }
}

public class Child1 : Base
{
    public Child1(int x) : base(x)
    {
    }
}

public class Child2 : Base
{
    public Child2(int x) : base(x)
    {
    }
}

public class Child3 : Base
{
    public Child3(int x) : base(x)
    {
    }
}

public class Program
{
    public static void Main()
    {
        Type[] childTypes = new Type[]{typeof(Child1), typeof(Child2), typeof(Child3)};
        foreach(Type type in childTypes)
        {
            Base child = xxx(type);
            child.GetX();
            Console.WriteLine(child.GetType());
        }
    }
    
    public static Base xxx(Type childType)
    {
        return (Base) Activator.CreateInstance(childType, 10); /* второй параметр будет передан в конструктор */
    }
}