Choose which class to instantiate c#

Question

Hi All, what i want to do is select the appropriate class to instantiate based on parenthesis passed in. Currently what i have are two classes (ClassA and ClassB) and to call these im using 2 methods depending on the parenthesis. What i would like to achieve is to use just one method to instantiate either ClassA or ClassB based on the string parenthesis passed.

I dont really know how i can pass back the class object to use..

My old way was in Method A to call the class to instantiate then i could use it. ClassA myclass = new ClassA();

I did think about using the following but i do not (if im honest) know how i instantiate the object o or use it when it is passed back by MyMethod. object o doesnt appear to give me access to the public string methods in Class A or Class B.

public class ClassA
{
    public ClassA()
    {
     //Do something for Class A
    }
    public string msgA()
    {
     return "Here is msg A";
    }
}

public class ClassB
{
    public ClassB()
    {
     //Do something for Class B
    }
    public string msgB()
    {
     return "Here is msg B";
    }
}

private string MyMethod()
{
    object o = GetClassToInstantiate("ClassA");
    //Use object o 
}

private object GetClassToInstantiate(string parameter)
{
    object temp = null;
    switch (parameter)
    {
     case "ClassA":
      temp = new ClassA();
      break;
    }

    return temp;
}

Any suggestions how i can solve this probably very easy situation.

Answer 1

What you need is a factory method in a base class:

enum ClassType { ClassA, ClassB }

class ClassBase
{
   public static ClassBase Create(ClassType  classType)
   {
       switch (classType)
       {
           case ClassType.ClassA: return new ClassA();
           case ClassType.ClassB: return new ClassB();
           default: throw new ArgumentOutOfRangeException();
       }
   }
}

class ClassA : ClassBase
{
}

class ClassB : ClassBase
{
}

Check the Wikipedia article on the Factory method pattern for more info.

Answer 2

You would be better off using a design pattern to do this. Take a look at the Abstract Factory and Factory Method patterns on the Gang of Four website.

Abstract Factory

Factory Method

Answer 3

What you want to do isn't generally considered a very useful operation. When you're done all you know about the result is that it's an object. You don't know about any methods or properties it provides. Since C# doesn't (currently-coming soon in v4) allow late binding you can't really do anything with the result.

It becomes much more interesting when class A and class B implement a common interface or are inherited from a common base class. In that case, you could have a generic method that instantiates your real class but returns it as the common interface. This is much more useful, for example with plugin archtitectures.

Answer 4

I would use a common interface for your classes and a seperate factory class with a generic factory method as follows:-

class Program
{
    static void Main(string[] args)
    {
        IAnimal animal = AnimalFactory.CreateAnimal<Dog>();

        animal.Speak();

        Console.ReadKey();
    }
}

public abstract class AnimalFactory
{
    public static IAnimal CreateAnimal<T>() where T : IAnimal, new()
    {
        return new T();
    }
}

public interface IAnimal
{
    void Speak();
}

public class Dog : IAnimal
{
    public void Speak()
    {
        Console.WriteLine("Woof");
    }
}

public class Cat : IAnimal
{
    public void Speak()
    {
        Console.WriteLine("Meow");
    }
}