Abstract Factory Patterns in C#

The ABSTRACT FACTORY PATTERN comes under the classification of Creational Patterns. The creational patterns deals with the best way to create objects. The Abstract Factory provides an interface to create and return one of several families of related objects. 

"Provide an interface for creating families of related or dependent objects without specifying their concrete classes" -- "Design Patterns" Gamma et al., Addison-Wesley, ISBN:0-201-63361-2" 

Non-software Example 

This pattern is found in the sheet metal stamping equipment used in the manufacture of Japanese automobiles. The stamping equipment is an Abstract Factory, which creates auto body parts. The same machinery is used to stamp right hand doors, left hand doors, right front fenders, left front fenders, hoods, etc. for different models of cars. Through the use of rollers to change the stamping dies, the concrete classes produced by the machinery can be changed within three minutes. [Michael Duell, "Non-software examples of software design patterns", Object Magazine, Jul 97, p54] 

The abstract factory is a factory object that returns one of several factories. It can be used to return one of several related classes of objects, each of which can return several different objects on request. 

The abstract factory pattern can be interpreted and implemented in many ways. The following is a simples interpretation and implementation of this pattern.  


 

In this case the interface Factory has two concrete implementations, ConcreteFactory1 and ConcreteFactory2. The getObject() inside these concrete classes returns Derived1 and Derived2 objects respectively. The client can decide which ConcreteFactory class has to be used during the run-times. 

The following is a more complicated interpretation and implementation of this pattern. Here those Factory class methods are used for returning objects of two different class hierarchies.  



C# Implementation 

// Creational Pattern: Abstract Factory Pattern
//Author: rajeshvs@msn.com
/*
In the following snippet, Factory is an interface. The concrete implementation of this interface ConcreteFactory1 and ConcreteFactory2 implements the method getObject so that it returns Derived1 and Derived2 objects respectively. The Base is an interface and Derived1 and Derived2 are the concrete implementations of the base class. The client (MyClient class) always uses the Factory implementations to create an instance of the Base classes. Actually the derived classes of Factory interface decided which object (either Derived1 or Derived2) has to be created.
*/
using System;
interface Factory
{
Base GetObject();
}
//This class is responsible for creating objects of the class Derived1.
class ConcreteFactory1 :Factory
{
public Base GetObject()
{
return new Derived1();
}
}
//This class is responsible for creating objects of the class Derived2.
class ConcreteFactory2 : Factory
{
public Base GetObject()
{
return new Derived2();
}
} 
interface Base
{
void DoIt();
}
class Derived1 : Base
{
public void DoIt()
{
Console.WriteLine("Derived 1 method");
}
} 
class Derived2 : Base
{
public void DoIt()
{
Console.WriteLine("Derived 2 method");
}
} 
/*
Client class Client class needn't know about instance creation. The creation of Product
is deferred to he ConcreteFactory1.
*/
class MyClient
{
public static void Main()
{
Factory factory = new ConcreteFactory2();//Decides which object must create.
Base obj = factory.GetObject();
obj.DoIt();
}
}