Home > .NET Development > Design Patterns – The Factory Method

Design Patterns – The Factory Method


Introduction


This article explains the Factory Method Pattern, which is one of the C# Design
Patterns.

This pattern gives you the ability to create a factory (instance) that will instantiate
many relatedobjects.


When to use the Factory Method?

  • A class can’t anticipate which kind of class of objects it must create.
  • A class uses its subclasses to specify which objects it creates.
  • You want to localize the knowledge of which class gets created.

Cooper – Introduction to Design Patterns in C#

You can think of this like if you have some different implementation for 1 parent
object, and
then you have some other different creators for these instances.., so we will have
a factory
that decides what creators and decide what instances does every creator instantiate.


The Pattern

Imagine we have a class called Message that sends some contents through the Send()
function.

And we have some types of messages (Email, sms, .. etc.) each of which has a special
implementation
of the send() function.

Now how to decide which type (instance) of message we will send if using a cell
phone or a PC?

So, this means we have different machines (cell, PC, Laptop..), and each machine
will instantiate

specific types of messages.


Message

  • The best way is to make an abstract class called Message and include an abstract
    method called Send(), So
    we can easily implement it.

        abstract class Message
        {
            abstract public void Send();
        }
    
  • Example of different implementations..
        class Email : Message
        {
            public override void Send()
            {
                Console.WriteLine(this.GetType().Name);
            }
        }
        class VoiceMail : Message
        {
            public override void Send()
            {
                Console.WriteLine(this.GetType().Name);
            }
        }
        class SMS : Message
        {
            public override void Send()
            {
                Console.WriteLine(this.GetType().Name);
            }
        }
        class MMS : Message
        {
            public override void Send()
            {
                Console.WriteLine(this.GetType().Name);
            }
        }
    

Machine

  • Now to make the machine.. Its the the factory that will decide which instances (types)
    of messages to instantiate,
    so if we have more than 1 machine, we can inherit from the machine and decide in
    the concrete factory.

        abstract class Machine
        {
            //The array of objects
            private List _messages = new List();
            public Machine()
            {
                CreateMachines();
            }
           
            //The function that each machine will override
            abstract public void CreateMachines();
           
            public List Messaages
            {
                get
                {
                    return _messages;
                }
            }
        }
    
  • Cell Phone and PC example..
        class CellPhone : Machine
        {
            public override void CreateMachines()
            {
                //Instantiating objects
                Messaages.Add(new SMS());
                Messaages.Add(new MMS());
            }
        }
    
        class PC : Machine
        {
            public override void CreateMachines()
            {
                //Instantiating objects
                Messaages.Add(new Email());
                Messaages.Add(new VoiceMail());
            }
        }
    

  • And this how we can use the factory..
    class Program
        {
            static void Main(string[] args)
            {
                Machine[] machines = new Machine[2];
                //The constructor is the one who calls CreateMachine()
                machines[0] = new CellPhone();//A machine
                machines[1] = new PC();//Another machine..
    
                foreach (Machine _machine in machines)
                {
                    Console.WriteLine("--" + _machine.GetType().Name);
                    foreach (Message _message in _machine.Messaages)
                    {
                        _message.Send();
                    }
                }
            }
        }
    
    


The Code

namespace Factory_Method
{
    class Program
    {
        static void Main(string[] args)
        {
            Machine[] machines = new Machine[3];
            machines[0] = new CellPhone();
            machines[1] = new PC();
            machines[2] = new Laptop();

            foreach (Machine _machine in machines)
            {
                Console.WriteLine("--" + _machine.GetType().Name);
                foreach (Message _message in _machine.Messaages)
                {
                    _message.Send();
                }
            }
        }
    }
    abstract class Message
    {
        abstract public void Send();
    }

    class Email : Message
    {
        public override void Send()
        {
            Console.WriteLine(this.GetType().Name);
        }
    }
    class VoiceMail : Message
    {
        public override void Send()
        {
            Console.WriteLine(this.GetType().Name);
        }
    }
    class SMS : Message
    {
        public override void Send()
        {
            Console.WriteLine(this.GetType().Name);
        }
    }
    class MMS : Message
    {
        public override void Send()
        {
            Console.WriteLine(this.GetType().Name);
        }
    }

    abstract class Machine
    {
        private List _messages = new List();
        public Machine()
        {
            CreateMachines();
        }

        abstract public void CreateMachines();
        public List Messaages
        {
            get
            {
                return _messages;
            }
        }
    }

    class CellPhone : Machine
    {
        public override void CreateMachines()
        {
            Messaages.Add(new SMS());
            Messaages.Add(new MMS());
        }
    }

    class PC : Machine
    {
        public override void CreateMachines()
        {
            Messaages.Add(new Email());
            Messaages.Add(new VoiceMail());
        }
    }

    class Laptop : Machine
    {
        public override void CreateMachines()
        {
            Messaages.Add(new Email());
            Messaages.Add(new VoiceMail());
        }
    }


}

Advertisements
Categories: .NET Development
  1. Amit
    May 30, 2008 at 2:44 am

    Thanks to islam ElDemery. It is a excellent piece of work from him. He helped me a lot…….

  2. Michael.Nagy
    June 9, 2008 at 1:18 pm

    nice job man .. begad gamed awi awi

  1. No trackbacks yet.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: