B.Factory Pattern

Objective
1. 1. It Create an objects/family of related object (like Pizza ingredients) with some special construction logic.
  2. Sole motive is to hides Object creation process from client.
When to use

- 1. If object construction is complex and you want to abstract (hide)
  2. If you have many objects of the same base type and you manipulate them mostly by casting to abstract types, then you need a factory.

1. Simple Factory
  1. 1. Client directly holds Concrete Factory and request object instance, factory creates and return abstract instance (interface). This is classic example of factory and use full when factories are not going to change in future.
    2. Further readings : http://www.oodesign.com/factory-pattern.html

- 1. Factory Method Pattern
    1. It is same as simple factory but concrete factories are derived from an abstract factory that allows organizing base line logic in base class. In this case Client still holds concrete factory and factory return abstract product instance (interface)
    2. Further Readings : http://www.oodesign.com/factory-method-pattern.html

- - 1. This is further augmentation of factory method pattern. In this pattern client holds an abstract factory instance that are capable to produce multiple component object such as automobile parts or pizza ingredients.
    2. Concrete factory actually implement actual object creation pattern. http://www.oodesign.com/abstract-factory-pattern.html

1. Factory Registration Issues
  1. 1. Any types of factories are implanted with class registration mechanism in which factory is made aware about that class it has to support and each class has a unique name or ID and client request the instance using the ID. There are two main types of Class Registration.
    2. Compile Time Registration
      1. This registration model is mainly switch case based and cannot be modified at run time.
    3. Run time Registration

- - - 1. Class registration via Reflection
        Loads component classes via reflection and assemblies can be configured via config files.
      2. Class registration via Configuration files

- - - - It also uses reflection but configuration files map ID Vs classes and assemblies.

- - - - Factories again uses reflection but assemblies are loaded from a drop folder and client request directly using full class names. These mechanisms involve minimal maintenance and deployment overhead.

- - 1. Any implementation of Abstract Factory Pattern must obey Dependency inversion principle to avoid hard coupling.

- - 1. Any implementation of Factory Pattern must obey DI principle to avoid hard coupling.

- - 1. Simple Factory: - Also called Simple Factory and Simply a class create any registered product. It is more about programming technique than design pattern.
    2. Factory Method :- A derived class creates just one type of concrete product

- 1. Abstract Factory:
    1. 1. Further extend Factory Method using inheritance logic and creates family of related products
      2. Core motivation is modularization

- 1. Factories are usually it non-extensible and implemented in custom way making them less reusable.

- - 1. Dependency Injection can be implemented using factory but because of limitations of factories it is suggested to use framework that provide Containers like Spring.Net . ref http://msdn.microsoft.com/en-us/magazine/cc163739.aspx#S1

- - 1. Static factory creator method should not be used, because being static it can't be changed/modified/extended. But if the static method picks info from some other source (like config file), it is OK.