What creational pattern I should use?

Question

My program have two classes; both derive from same base class.

class A : MyBase
{
    internal A(InitVal initVal)
}

class B : MyBase
{
    internal B(InitVal initVal)
}

InitVal is another class which is injected through constructor. This class is for internal usage. Due to internal constructor, user cannot create instance of class A and B directly. Instead, I created method which creates these objects.

class Initiator
{
    InitVal initVal;

    public T CreateObject<T>(ObjectInstance objectInstance) where T : MyBase
    {
        MyBase myBase = null;
        switch(objectInstance)
        {
            case ObjectInstance.A:
                myBase = new A(initVal);
                break;
            case ObjectInstance.B:
                myBase = new B(initVal);
                break;
        }
        return (T)myBase;
    }
    ...
}

ObjectInstance is enum in above code.

This works without problem but I am sure you have never seen such ugly code earlier.

Please suggest creational pattern I should use. I want to remove ObjectInstance enum without changing functionality. It will cleanup much.

I tried Creational Patterns mentioned on dotfactory. Factory Method and Abstract Factory does not look proper in this case.

My code even though look ugly, it is very simple to read and understand. I tried implementing patterns mentioned above which increases code complexity. So this is also my criteria while choosing answer.

I cannot change anything in code except Initiator class. All other classes are not accessible to me for edit.

Edit 1: Why above code is ugly in my view

1) While calling CreateObject method, user have to specify type of the object twice.

A a = initiator.CreateObject<A>(ObjectInstance.A);

First for T generic value and second to enum value. I want to avoid this.

2) As user has to specify type of object twice, there are chances of mistake.

A a = initiator.CreateObject<A>(ObjectInstance.B);

In above code, enum value and generic value are different. This is not allowed and will be a problem. With my code, I cannot avoid this.

That is why; I am looking for pattern that suits my case without increasing complexity.

If I remove necessity of enum somehow, code will be lot better. If I can change signature of CreateObject to following, it will be lot better.

public T CreateObject<T>() where T : MyBase

But, I am not sure how I will implement this method to create proper instances.

Answer 1

It doesn't look to me like you are getting any advantage from trying to make this generic. You needs to know the concrete type of the returned value at the call site.

Therefore why not keep things simple and just do this?

public class Initiator
{
    InitVal initVal;

    public A CreateA()
    {
        return new A(initVal);
    }

    public B CreateB()
    {
        return new B(initVal);
    }
}