Intent:

Provide interface for creating families of related or dependent classes without specifying there concrete classes.

Scenario:

I have been wondering about a valid scenario where I would put the Abstract Factory Into play. To be honest it took me some time to really find a valid scenario where I should use it. The catch is "creating families of related or dependent classes", and where would one need this. Where is it being used. We are currently working on development of a framework. Initially it used to have a Telerik controls based UI. And we also used the Ribbon Bar implementation on top of the telerik controls. What this did was made our pages heavy, in the rounds of ~2MB. This made us thinking, not everybody, would be happy to use it this way, so we thought of coming up with a light UI something that limits the page sizes considerabley. In the light UI, we are not using any ribbon controls, rather its a normal menu. Having said that, the solution that you are going to see is just not Abstract Factory only, so I would just omit out the other unrelevant in the context of the post. Apart from the above mentioned scenario, the other place it gets utilizied is ADO.Net. The idea is if you are using a SQL Data Provider then the Connection class should be of SqlConnection noly, like wise the SQLCommand class, the SQLDataAdapter class and so forth. But instead if you are connecting to a MySQL Database, then the connection class would be probably MySqlConnection class and like wise, MySqlCommand class and so forth. If you can notice a pattern, we are talking of creating a family of related products. Lets now look at the Abstract Factory:

• You define Abstract classes for the related products- In our case, we will have AbstractButton, AbstractDropdown for the UI Problem and in case of ADO.Net we have IDBConnection interface and IDBCommand and etc.
• Then you define a Abstract Factory for creating the different instances of your abstract products - In our case, we would have CreateButton, CreateDropdown etc. I am not aware if, ADO.Net does provide a factory class.
• Then what we need is implement the Abstract classes and Abstract Factory for creation of the related products and each group of related products being reprsented by a Implementation of the Factory.

• You abstract the creation process of the components from the code and this allows you to replace it by some other implementation of the Abstract Product. Flexibility and loose coupling is what you gain.
• Reusablilty of the same code that uses your Abstract Products.

using System;


namespace Coderslog.Tryst.DesignPatterns
{
    //interface representing a Button
    public interface IButton
    {
        //Button Properties
    }

    public class SimpleButton : IButton
    {
    }
        
    public class RichButton : IButton
    {
    }

    //interface representing a TextBox
    public interface ITextBox
    {
        //TextBox Properties
    }

    public class SimpleTextBox : ITextBox
    {
    }
    
    public class RichTextBox : ITextBox
    {
    }

    //Abstract Factory interface for Creating UI Components
    public interface IUIComponentFactory
    {
        IButton GetButton();
        ITextBox GetTextBox();
    }

    //Factory Class for Creating Simple UI Components
    public class SimpleUIFactory : IUIComponentFactory
    {

        #region IUIComponentFactory Members

        public IButton GetButton()
        {
            return new SimpleButton();
        }

        public ITextBox GetTextBox()
        {
            return new SimpleTextBox();
        }

        #endregion
    }

    //Factory Class for Creating Rich UI Components
    public class RichUIFactory : IUIComponentFactory
    {
        #region IUIComponentFactory Members

        public IButton GetButton()
        {
            return new RichButton();
        }

        public ITextBox GetTextBox()
        {
            return new RichTextBox();
        }

        #endregion
    }


    ///Usage
    public class UIComponentFactory : IUIComponentFactory
    {

        private IUIComponentFactory _internalFactory;

        public UIComponentFactory()
        {
            _internalFactory = new RichUIFactory();
        }

        public UIComponentFactory(string config)
        {
            if (config == "Simple")
                _internalFactory = new SimpleUIFactory();
            else
                _internalFactory = new RichUIFactory();
        }

        #region IUIComponentFactory Members

        public IButton GetButton()
        {
            return _internalFactory.GetButton();                
        }

        public ITextBox GetTextBox()
        {
            return _internalFactory.GetTextBox();
        }

        #endregion
    }

}

Having outlined an approach, even if its not a approapriate one, we are now intrested in seeing a better solution that is much cleaner than the previous one.

As we re-collect from the previous post our generalized problem was, "There is a addition to behaviour in some scenarios".

We decided to use a Decorator.

What we did was created a interface called IWebPageGenerator, which had a method Generate. Now, the original class was made to  implement from the interface IWebPageGenerator.And all the calls we initiated in the original class was from the Generate Method.

As for the scenario which required a Security check what we did was,

/*           SecurityDecorator                    */

public class SecurityDecorator:IWebPageGenerator{

      public IWebPageGenerator ChildWebPageGenerator {get; private set;}

      public SecurityManager _securityManager;

      public SecurityDecorator(IWebPageGenerator childWebPageGenerator){

             ChildWebPageGenerator = childWebPageGenerator;

             _securityManager = SecurityManager.Instance.Context(Privelege.Metadata.Update);

      }

      public string Generate(){

             _securityManager.Verify();

             return ChildWebPageGenerator.Generate();  

      }

}

/*               Usage                            */

var  webPageGenerator = new SecurityDecorator(webPageGenerator);

/*                                                */

As you can see what this approach brings in is lesser number of code changes. And a more cleaner code base. And the bonus is a better infrastructure of Web Pages Generator which is flexible and extensible.

- Till then Happy Coding :)