Cost of Reflection while using factory

Question

Good people of stackoverflow,

As always, I am writing a factory in order to dynamically instantiate objects.

To schematize, I have four types:

class CatDescriptor : PetDescriptor
class DogDescriptor : PetDescriptor

class Cat : Pet
class Dog : Pet

I instanciate the two last types from the factory. And here comes the dilemma: Should I just test the descriptor types with the "is" operator which hides reflection and then cost something.

static Pet.Factory(PetDescriptor descriptor)
{
    if (descriptor is CatDescriptor)
    {
        return new Cat();
    }
    else if (...)
    {
        ...
    }
}

Should I use an Enum "Type" as an attribute embedded in the PetDescriptor.

class PetDescriptor
{
    public Type PetType;

    public enum Type
    {
        Cat,
        Dog
    }
}

static Pet.Factory(PetDescriptor descriptor)
{
    switch (descriptor.PetType)
    {
        case PetDescriptor.Type.Cat:
            return new Cat();
        ....
    }
}

Or use virtual methods:

class PetDescriptor
{
    public virtual bool IsCat()
    {
        return false;
    }

    ...
}

class CatDescriptor : PetDescriptor
{
    public override bool IsCat()
    {
        return true;
    }
}

static Pet.Factory(PetDescriptor descriptor)
{
    if (descriptor.IsCat())
    {
        return new Cat();
    }
    else if (...)
    {
        ...
    }
}

Votes are opened !

edit: question is about reflection performance, and not factory design.

Answer 1

Having tests in your factory defeat the purpose (you'll have to update your class for every new concrete instance you want to create).

You can either :

• Use the abstract factory pattern

• (much better) use a IoC framework to instanciate your objects for you (I'd suggest Castle Windsor, NInject or if you're in a MS shop only, Unity).

Answer 2

Your third solution (with virtual method) is definitely out : the PetDescriptor class should not know about all it's derived classes (you would have to add a new method IsXXX every time you create a XXXDescriptor class).

I think your first solution is the best. The enum doesn't add anything useful, it just forces you to add more code in descriptor classes

Answer 3

You don't want to have a single factory class you want to have factoriy classes for each Tyep of pet.

They should all implement a Pet factory interface.

The way you have it every time you add a new pet you will have to edit the Pet factory, rather than just creating a new pet factory class and using that.

Alternatively each pet class could be responsible for creating instances of itself (or the pet descriptor whcih is linked to a pet. Have a look at the Factory method pattern:

http://en.wikipedia.org/wiki/Factory_method_pattern

http://www.dofactory.com/Patterns/PatternFactory.aspx

At least thats my understanding.

Answer 4

Since your PetDescriptor identifies the Pet I would use overload:

static class PetFactory
{
    public static Dog CreatePet(DogDescriptor descriptor)
    {
        return new Dog(descriptor);
    }

    public static Cat CreatePet(CatDescriptor descriptor)
    {
        return new Cat(descriptor);
    }
}

(edit)

Of course, this only works if you have a concrete PetDescritor : CatDescriptor or DogDescriptor.

If you don't have the abstract PetDescriptor upon creation I would go with the first solution.

Alternately, you could declare an Enum in the Factory class that would specify with concrete Pet you like to create. The Wikipedia has a simple example with Pizza.