Factory Design Pattern for SearchFactory - A Practical Approach

• Download source files - 11.2 KB

Introduction

Abstraction concretes almost everything!! The idea here is to promote the power of Factory design patterns in one of my latest personal projects. My project deals with content searching for documents and returning results that are displayed in a grid (typical methodology of showing search results, isn’t it? :)). This code article deals with the architecture of the searching module which I have implemented to solve typical problems and to make the architecture more candid and tangible. This article might be helpful for those who are developing similar kinds of applications and are looking for similar abstractions. Please note that this article deals with design concepts, so the body of the methods in the code have been kept empty. You can insert your own code to make them work!!

Background

There are quite a few articles of abstract factory design available on the internet. Most of them include bookish examples like draw, run, move, play, etc… not for developers who demand cutting edge solutions (no offence meant).

“The Factory design pattern deals with the way objects are created. There is one parent class which defines the parameterized factory method to create the object of its child class based on the parameters passed”.

Using the code

The code structure is very simple. There are four classes viz. SearchFactory, ProximitySearch, SimilaritySearch, and SimpleSearch.

There are three types of searches in my module viz. Proximity, Similarity, and Simple. Detailed description on how these searches perform is out of the scope of this article (I will post it separately :)).

The code here defines the SearchFactory class as an abstract class which has a factory method called GetSearchObject(). This method is also called parameterized factory method which takes a parameter for the type of object that is to be created. All the three searches have one class each, defined in the code. All these classes (ProximitySearch, SimilaritySearch, SimpleSearch) inherit the SearchFactory class to provide a concrete implementation.

Apart from the Factory method, SearchFactory (the base class of all searches) defines several other abstract functions which are common for all these three types of searches (simple search, proximity search, and similarity search). The idea is to make all of them abstract in SearchFactory and let each search override each of those abstract functions.

Those abstract functions are as follows:

public abstract void GetSearchResult(); 
public abstract void ExecuteSearch();
public abstract void SaveAndSearch();
public abstract void ValidateSearch();
public abstract void UpdateDisplayName();

You can refer to the code for this. The typical search factory method is given as follows. Based on the parameter searchType, an object will be created for ProximitySearch, SimpleSearch, and SimilaritySearch.

public static SearchFactory GetSearchObject(string searchType)
{
    SearchFactory objContentSearchObject = null;
    if(searchType.ToString().ToUpper() == "SIMPLE")
    {
        objContentSearchObject = new SimpleSearch();    
    }

    if(searchType.ToString().ToUpper() == "PROXIMITY")
    {
        objContentSearchObject = new ProximitySearch();    
    }

    if(searchType.ToString().ToUpper() == "SIMILARITY")
    {
        objContentSearchObject = new SimilaritySearch();    
    }

    return objContentSearchObject;
}

Conclusion

This article targets developers who are starving to get a practical usage of design patterns. This article is at the draft level, and may contain a few errors or bugs and thereby I welcome suggestions or criticism!! Developers who would like to challenge my code can write their comments on this code without any hesitation. Starving for perfection :).