C＃-在抽象超类中生成相同类型的新具体类

Question

I have an abstract base class with for example two subclasses. In the abstract class I use the template pattern in the "real world" but for this example lets say I have a generator method which returns the type AbstractBaseClass . Now I want the instance to be the concrete type at runtime. This is important for the template pattern as I use different implementations and hooks in each subclass.

For now I came up with the following pseudo code. I check whether this is a concrete class and call the constructor of either one of the subclasses and return the new Instance.

public abstract class AbstractBaseClass
{
    private string _someString1;
    private string _someString2;

    protected AbstractBaseClass(string someString1, string someString2)
    {
        _someString1 = someString1;
        _someString2 = someString2;
    }

    public AbstractBaseClass GenerateClass()
    {
        //...

        if(this is SubClass1)
        {
            return new SubClass1("Foo1", "Foo2");
        }

        if(this is SubClass2)
        {
            return new SubClass2("Foo3", "Foo4");
        }
        return null;
    }

    // more methods
}

public class SubClass1 : AbstractBaseClass
{
    public SubClass1(string someString1, string someString2) : base(someString1, someString2)
    { }

    // more methods
}

public class SubClass2 : AbstractBaseClass
{
    public SubClass2(string someString1, string someString2) : base(someString1, someString2)
    { }

    // more methods
}

So far so good. But now I want my code to be open for extensions but closed for modifications . I want to be able to add as many subclasses as I want, but don't have to change the generator method. How can this be achieved?

So it gets decided at runtime which instance to create. Keep in mind that I don't have an empty constructor. But there is in every case a constructor with the same signature.

I found this post. It seems to go this direction but it didn't really helped me:

• stackoverflow - Get a new object instance from a Type

Thanks!

Answer 1

you should use the Factory Pattern here :

Define an interface for creating an object, but let subclasses decide which class to instantiate. The Factory method lets a class defer instantiation it uses to subclasses.

for example, though not fully qualified as Factory pattern, take a look at this snippet:

public abstract class A
{
 // Some abstract stuff

 public static A CreateInstance(Type myType)
 {
   Type type = myType; // pseudo method
   return (A)Activator.CreateInstance(type);  
 }
}

you can initialize all of your subclasses in one method.

I advice you to look deeper into Abstract Factory Design Pattern In C# in order to learn and understand the concept better.

Edit:

---

Or as suggested by the comment for a better generic solution:

public abstract class A
{
  // Some abstract stuff

  public static A CreateInstance<T>() where T : A, new() => new T();
}

Answer 2

try this :

public AbstractBaseClass GenerateClass()
{

    return (AbstractBaseClass) Activator.CreateInstance(this.GetType(), StringParametter1,StringParametter2);
}

Good luck !