Retrieving classtype during runtime

[Malfunction]

I have three classes inheriting from Base class:

class Base

class Child1

class Child2

class Child3

 

Now I need this method:

void CreateNewInstance(Base someObject)

{

ActualType newObj = new ActualType();

}

 

ActualType will either be Child1, 2 or 3 but how do I get it?

[PlausiblyDamp]

It may be worth explaining why you need to do this - if a function is expecting any derived class then it can only safetly call functionality from the base class, why do you need to create a new instance of this variable within the function?

You could always create a new instance and have the variable type set to Base, but declaring the variable type on the fly will involve an awful lot of effort.

 

If you want to create an instance on the fly the following should work - I'm not convinced that this is the best approach to your problem though...

void CreateNewInstance(Base someObject)
{
Type t= someObject.GetType();
Base newObj =(Base) System.Activator.CreateInstance(t, true);
}

[Joe Mamma]

one technique is to enumerate you class hierarchy and have a static 'class factory' method off of the base:

 

 enum ClassType
{
 class1, class2, class3
}
public class BaseClass
{
 public static BaseClass Create(ClassType aClass)
 {
  switch (aClass)
  {
case class1:
 return new Class1();
case class2:
 return new Class2();
case class3:
 return new Class3();
  }
 }
}
public class Class1: BaseClass{}
public class Class2: BaseClass{}
public class Class3: BaseClass{}
public class ClassUser
{
 public void Test()
 {
  BaseClass bc1 = BaseClass.Create(class1);
  BaseClass bc2 = BaseClass.Create(class2);
  BaseClass bc3 = BaseClass.Create(class3);
 }
}

[Malfunction]

one technique is to enumerate you class hierarchy and have a static 'class factory' method off of the base:

...

 

thx geat solution ...

[John_0025]

Joe Mamma is correct.

However I don't think the class factory should be in the baseclass. It doesn't make sense for a base class to contain information about classes that are derived from it.

 

public interface iBaseClass{}

public class Class1: iBaseClass{}
public class Class2: iBaseClass{}
public class Class3: iBaseClass{}


public class ClassUser
{
public enum ClassType
{
	class1, class2, class3
}

public void Test()
{
	iBaseClass bc1 = Create(ClassType.class1);
	iBaseClass bc2 = Create(ClassType.class2);
	iBaseClass bc3 = Create(ClassType.class3);
}
public iBaseClass Create(ClassType aClass)
{
	switch (aClass)
	{
		case ClassType.class1:
			return new Class1();
		case ClassType.class2:
			return new Class2();
		case ClassType.class3:
			return new Class3();
		default:
			return null;
	}
}

} 

 

p.s. This looks like a project where using an interface instead of a base class might be better.

Edited August 23, 2004 by John_0025