C# Design Patterns: #2 – The Factory Method

One of the less useful C# design patterns is the Factory Method.  Primarily used for framework and toolkit development, this design pattern is rarely used in a language like C# that has templated classes, anonymous functions, interfaces, and reflection.

Factory methods are mainly used when developing a framework, or a set of functions, classes, and general infrastructure that will be used by other developers to create applications.  Since different applications will have different use cases, the applications developed using a particular framework may need to override the underlying classes and replace them with their own implementation.

For example, a framework called the SimpleDatabase framework might help developers create applications through Rapid Application Development.  The framework might have a set of classes that automatically generates the interface and database logic, based on a particular schema.  When developers implement this framework, they might occasionally need to implement custom database drivers for a particular database.  In this example, the framework handles creation of the database connections, and the developers need to subclass the framework to instantiate their custom database driver instead of the default driver:

public class Program{
  public static void Main(){
    SimpleDatabaseApp sda = new AccountingSystemApp();
    sda.CreateDBConnection();
  }
}
 
public class SimpleDatabaseApp {
  public virtual SimpleDBConnection CreateDBConnection(){ return new SimpleDBConnection(); }
}
 
public class SimpleDBConnection { /* Default database driver here */ }
 
public class AccountingSystemApp : SimpleDatabaseApp {
  public override SimpleDBConnection CreateDBConnection() { return new OracleDBConnection(); }
  /* Implements the rest of the accounting system here */
}
 
public class OracleDBConnection : SimpleDBConnection { /* Oracle database driver here */ }

In this example, the SimpleDatabase framework is used to create the AccountingSystemApp.  The OracleDBConnection will be used instead of the default SimpleDBConnection.  To make this happen, the AccountingSystemApp overrides the “factory method” called CreateDBConnection that actually instantiates the class, and this will instantiate the Oracle driver instead of the default driver.

When implementing this pattern, it’s very important to use the “override” keyword instead of the “new” keyword in the subclass.  The C# compiler will otherwise bind to the default factory method on the base class, instead of the new factory method.

The basic reason that the function “CreateDBConnection” is called a factory method is that it “manufactures” a new class.  While normally the class would be instantiated by the control loop, here instead the framework instantiates the class in the CreateDBConnection method.

Note: “Factory Method” refers to the actual function inside the class, not the class itself.

The reason factory methods aren’t popular in C# is that there are many excellent alternatives.  Templated classes are used heavily throughout the language, as in the implementation of IEnumerables such as Dictionary and List.  Alternatively, Reflection enables classes to create member variables based on a Type, instead of requiring the subclass to manually create the variable.  If all of these options were not enough, C# also supports anonymous functions, enabling dependency injection as opposed to factory methods.

Overall, the factory method design pattern is not particularly useful in the C# language, however it may help in the development of certain highly-customizable C# frameworks and toolkit packages.

Written by Andrew Palczewski

About the Author
Andrew Palczewski is CEO of apHarmony, a Chicago software development company. He holds a Master's degree in Computer Engineering from the University of Illinois at Urbana-Champaign and has over ten years' experience in managing development of software projects.
Google+