Question

I have this little OO problem..

abstract class MyAbstractBaseClass
{    
   MyHelperClassBase myHelperBaseClass;

   protected method foo()
   {
       //QUESTION....... :  when I am here I want to do this...

       myHelperBaseClass = new MyHelperSubClass(); 

       //OR...

       myHelperBaseClass = new MyOtherHelperSubClass();

       //HOWEVER ITS COMPLETELY CONDITIONAL ON THE BASE CLASS
       //HOW DO I MAKE SURE THE CORRECT TYPE IS INSTANTIATED DEPENDANT ON
       //THE BASE CLASS WITHOUT USING AN 'if' STATEMENT?
   }    
}

class MySubClass : MyAbstractClass {}    
class MyOtherSubClass : MyAbstractClass {}    
/////////////

abstract class MyHelperClassBase {}    

class MyHelperSubClass : MyHelperClassBase, IMyHelper {}    
class MyOtherHelperSubClass : MyHelperClassBase, IMyHelper {}

I want to be able to have a the type basically passed up but cant think of a slick way to do this. Should I just stuck an abstract property on the base class?

Answer 1

The older OO way of solving this (without generics) involves a virtual or abstract method on the base that the derived classes must implement. This is pretty common in parallel hierarchies like your example:

abstract class MyAbstractClass{

    MyHelperClassBase myHelper;

    protected void foo() {
        myHelper = createHelper();
    }

    protected abstract MyHelperClassBase createHelper();
}

class MySubClass : MyAbstractClass{
    protected override MyHelperClassBase createHelper(){
        return new MyHelperSubClass();
    }
}

class MyOtherSubClass : MyAbstractClass{
    protected override MyHelperClassBase createHelper(){
        return new MyOtherHelperSubClass();
    }
}

Generics come in very handy, but sometimes it’s good to know this way, too.