Create an instance of derived class from the base class

Question

I have my abstract base class A:

public abstract class A : ICloneable {
 public int Min { get; protected set; }
 public int Max { get; protected set; }
 public A(int low, int high)
 {
 this.Min = low;
 this.Max = high;
 }
 //...
 public object Clone()
 {
 return new this(this.Min, this.Max); //<-- ??
 }
}

Which is extended by my class B:

public class B : A
{
 public B(int low, int high) : base(low, high) { }
 //...
}

Since A is abstract, it cannot be instantiated, but the derived class can. Is it possible to, from class A, create a new instance of class B?

Suppose class A has many derived classes, how will it know which one to instantiate?

Well, I want to instantiate the same class (or type) my currently A is.

That is, if I'm calling the Clone method from a class B, I want to instantiate a new B. If I'm calling the Clone method from a class C, I want to instantiate a new C.

My approach was to write something like:

return new this(this.Min, this.Max);

But that doesn't seem to work nor compile.

Is it possible to accomplish this in C#?

If it isn't, is there an explanation so I can understand?

• Ondrej Svejdar: This does not answer your question, but why are you not using this.MemberwiseClone() instead ?
• Matias Cicero: I was not aware of a MemberwiseClone() method, but I just want the copy to be a new instance, with the same constructor arguments. Any other processing MemberwiseClone may do would be useless
• Sriram Sakthivel: What if B construtor adds one more parameter?
• Matias Cicero: I hope that doesn't happen

Answer 1

Yes, this is possible with an abstract factory method on your base class

public abstract class A
{
 public int Min { get; protected set; }
 public int Max { get; protected set; }
 public A(int low, int high)
 {
 this.Min = low;
 this.Max = high;
 }
 protected abstract A CreateInstance(int low, int high);
 public object Clone()
 {
 return this.CreateInstance(this.Min,this.Max);
 }
}
public class B:A
{
 public B(int low, int high)
 : base(low,high)
 {
 }
 protected override A CreateInstance(int low, int high)
 {
 return new B(low,high); 
 }
}

• Matias Cicero: This solution crossed my mind too, but I was looking forward to not adding construction code in each derived class, but let C# do it for me, instantiating whatever derived class is being used to extend A. I hope I'm explaining myself well enough
• Jamiec: @MatiCicero - that's doable but you're going to be dabbling in a lot of reflection. Consider if this is the right solution for you
• Matias Cicero: I'll test both answers and come back with a conclusion. Thank you

Answer 2

While I like Jamiec solution, I'm missing dirty solution using reflection :)

public class A {
 public object Clone() {
 var type = GetType().GetConstructor(new[] { typeof(int), typeof(int) });
 return type.Invoke(new object[] { this.Min, this.Max });
 }
}

• Jamiec: +1 for the obvious reflection solution that works with non-parameterless ctors
• Matias Cicero: Ohhhh dirty, I like it :D

Answer 3

This can be done and your current approach is a well defined design pattern, though most implementations make the Clone an abstract virtual method and override it in all subclasses.

public abstract class A
{
 public abstract A Clone( );
}
public class B : A
{
 public override A Clone( )
 {
 return new B( );
 }
}
public class C : A
{
 public override A Clone( )
 {
 return new C( );
 }
}

Since you are using C# you could make use of the Activator class. You can make the Clone method virtual (not === abstract) with a default implementation of.

public abstract class A
{
 public virtual A Clone( )
 {
 // assuming your derived class contain a default constructor.
 return (A)Activator.CreateInstance(this.GetType( ));
 }
}

Edit - If you do not have a default parameter-less constructor in all of your derived classes, you can add parameters to the Activator.CreateInstance method

(A)Activator.CreateInstance(this.GetType( ), this.Min, this.Max);

For varying constructors on the derived types I would recommend you override the Clone method specifically for those types instead of using the default implementation of Clone.

• Jamiec: That last example will have to cast the response to A as in return (A)Activator.CreateInstance(this.GetType( )); as Activator.CreateInstance returns object
• Matias Cicero: This is exactly what I wanted, I will test it and come back with news
• Jamiec: The problem with this solution is it relies on a parameterless constructor, which the OP does not have. For reflection solution that works with your constructor look at the other answer @MatiCicero
• rtlayzell: There is nothing stopping you from adding parameters to the Activator.CreateInstance method. I chose to omit them because derived class constructors are unknown within the scope of A (see edit for continuation..)