Type.MakeGenericType

Type genericWithoutTypeArguments = typeof(Dictionary<,>);
// Если убрать комментарий, то мы получим исключение т.к. у типа нет тип-аргументов
// ArgumentException: Cannot create an instance of System.Collections.Generic.Dictionary`2[TKey,TValue] because Type.ContainsGenericParameters is true.
// object dict1 = Activator.CreateInstance(genericWithoutTypeArguments);
 
Type genericWithTypeArguments = genericWithoutTypeArguments.MakeGenericType(typeof(string), typeof(int));
// Успешно создаем Dictionary<string,int>
Dictionary<string,int> dict2 = (Dictionary<string,int>)Activator.CreateInstance(genericWithTypeArguments);

private void ShowList(Type type)
        {
            Type generic = typeof(ControlVocabularyList<>);
            Type[] typeArgs = { type };
            Type constructed = generic.MakeGenericType(typeArgs);
 
            object o = Activator.CreateInstance(constructed, new object[] { this.mApp });
            Control control = o as Control;
 
            if (control != null)
            {
                this.mApp.Controls.Show(control);
            }
        }

class SomeModel<T>
{
    public int FirstProperty { get; set; }
    public string SecondProperty{ get; set; }
    public void MeMethod <T> (T someArgument)
    {
        //implementation
    }
}
 
class TargetModel
{
    public int someProperty_1{ get; set; }
    public int someProperty_1{ get; set; }
}

Type type= typeof(SomeModel<>);
                Type typeForCreateInstance = type.MakeGenericType(typeObtainedByReflection);
                var myObject = Activator.CreateInstance(typeForCreateInstance );

(SomeModel<TargetModel>)myObject

var myObject = Activator.CreateInstance(typeForCreateInstance);
typeForCreateInstance.GetMethod("MeMethod")
    .MakeGenericMethod(typeof(string))
    .Invoke(myObject, new object[] { "Hello" });

class TestObjectModel
    {
        public delegate IBaseTestObject CreateMethod();
        public TestObjects EnumTestObject { get; set; }
        public CreateMethod DefaultConstructor { get; set; }
 
 
        public TestObjectModel(Type obj, object myObject)
        {
            DefaultConstructor = (CreateMethod)Delegate.CreateDelegate(typeof(CreateMethod), myObject, obj.GetMethod("SpecialMethod"), true);
        }
    }

var baseInterfaceType = typeof(IBaseTestObject);
                var objectsThatImplementBaseInterface = AppDomain.CurrentDomain.GetAssemblies().SelectMany(asem => asem.GetTypes())
                                                                 .Where(x => baseInterfaceType.IsAssignableFrom(x) && x.IsClass).ToList();
                foreach(var obj in objectsThatImplementBaseInterface)
                {
                    var myObject = Activator.CreateInstance(obj);
                    TestObjectModel tom = new TestObjectModel(obj, myObject);
                 }
//....

class Address_Test: IBaseTestObject
{ 
    public IBaseTestObject SpecialMethod()
    {
        return new Address_Test();
    } 
}

public IBaseTestObject GetObject(string objectName)
{
switch(objectName)
{
case "Address": return new Address_Test)();
case "": return new ...
//...
default: return null;
}
}

public IBaseTestObject CreateNewInstance(string testObjectName)
        {
            return TestObjectModels[testObjectName].DefaultConstructor.Invoke();
}