We are working on an application to process various XML messages and load them into a datastore. One of the devs I am working with created a Singleton Factory utilizing reflection to create an instance of the appropriate message subclass. My question is around using a singleton for the factory…(Using the samething for building the SqlCommand object need to pass to DB). The factory definitely makes sense here the part I am fuzzy about is using Singleton in conjunction with the Factory.
I have read a lot of postings, stackoverlow responses, etc and it still isn’t clear to me why for this scenario we would use that pattern (Singleton with factory…I would assume just use a factory pattern?).
Just trying to better understand as what I have gathered you would want to use Singleton when you want to ensure one and only one interface?
Singletons do not ensure a single interface; they ensure a single instance of an object that is accessible globally to other objects. An example of where you might want to use a singleton is when you need a counter that is accessible from anywhere in the application. In other words the state of that single object is maintained throughout the applications lifetime.
Factories on the other hand are used to create object where you do not necessarily know the exact type of class that is returned. For example, you may have a factory that returns an automobile object but the exact class that is returned might be a Volkswagen or it might be a Ferrari.
Factories are used a lot for dependency injection (DI). So in the example you give you can use a factory to return an object that interfaces with a DB, but the actual class may interface with a DB using SQL statements or maybe it is another class that uses an object-relational mapping (ORM) framework. This decouples the actual database interface/implementation from the rest of the application and allows more flexibility in changes to DB access going forward. The factory could even return a mockup of the DB access that can be used for unit testing. DI can be used to change which method is used at run-time. I would definitively recommend using Factories for these reasons.
Factories can also return singletons. So the question to ask in determining if you need a singleton is, do I need to maintain state across the application for all of the objects that will access this. An example of wanting to maintain state is that you want to keep the connection open to the database for any object that accesses this DB object for the life of the application. Not suggesting you do this but it just an example of why you may want to maintain the state information of that object for the life of the application.