Design Pattern For Beginners - Part-2: Factory Design Pattern

using System;  
using System.Collections;  
using System.Data.SqlClient;  
using System.Threading;  
  
namespace Test1  
{  
    public interface ISupplier  
    {  
        void CarSupplier();  
    }  
    class namo : ISupplier  
    {  
        public void CarSupplier()  
        {  
            Console.WriteLine("I am nano supplier");  
        }  
    }  
    class alto : ISupplier  
    {  
        public void CarSupplier()  
        {  
            Console.WriteLine("I am Alto supplier");  
        }  
    }   
    class CarFactory  
    {  
        public static ISupplier GiveMyCar(int Key)  
        {  
            if (Key == 0)  
                return new namo();  
            else if (Key == 1)  
                return new alto();  
            else  
                return null;  
        }  
    }   
    class Program  
    {  
        static void Main(string[] args)  
        {  
            ISupplier obj = CarFactory.GiveMyCar(0);  
            obj.CarSupplier();   
            obj = CarFactory.GiveMyCar(1);  
            obj.CarSupplier();   
            Console.ReadLine();  
        }  
    }  
}

Try to understand the following few lines carefully. As we indicated, we can add many more models in the future. Suppose we add seven or even 10 (or your preferred number) more models. In that case, the client code will also not be affected by a single line because we will add code in the factory class, not in the client, and will inform the client that, from now on, those models are also available; send the proper code (such as 0 for nano, 1 for alto) to get them.

Now return to my story of a walking stick. The walking stick was changed in behavior depending on needs. And just now, we have seen our factory class supplying a different object form depending on conditions. Somehow both share an expected behavior, right?

OK, now you may think, what a useless example this is. Car class? We don't know when our company will get a project from a car merchant, and we will implement the CarFactory class there.

OK, then let me show you a very realistic example that you can implement in your current project; yes, tomorrow morning.

Here we will learn how to implement a vendor-independent data access mechanism using a factory class. No, we will not create our factory class to do that; we will use a Dbfactory class from the .NET library.

Let's clarify our purpose again: "We will implement such a data access mechanism that is able to talk with various database vendors.".

Today you have developed one software product by targeting one of your clients who use SQLServer as their database. You have designed and implemented the necessary coding for SQLServer. At first, we will learn why we need to know. (Yes ADO.NET code, sqlconnection, sqlcommand bla bla..)

Now tomorrow, the client may say that we are not happy with SQLServer, and we have decided that from now we will use Oracle as our backend database.

The drama starts here. Let me explain the first scene.

By getting this proposal in the mail (from the client), the project manager will call the team leader of this product's team. After an hour of discussion, they will decide, "They need to change the data manipulation policy." It will take 30 days more to fix by five resources, and the budget for that is $$.

Now the client has received mail from the Software Company and replied: "Why do you people disclose the matter at the very first, and we are unable to give a single $ and day to do so., And we want to get it done within this time limit.".

What "If we develop such a data-accessing mechanism that will be compatible with all database vendors"? OOHhh, it's getting very complex; we will not go further. Have a look at the following code.

using System;  
using System.Collections;  
using System.Data.SqlClient;  
using System.Threading;  
using System.Data.Common;  
using System.Data;  
  
namespace Test1  
{  
   class Program  
    {  
        static void Main(string[] args)  
        {  
            DbProviderFactory provider = null;  
            DbConnection con = null;  
            DbCommand cmd = null;  
            DbDataReader rdr = null;  
            DataTable dt = new DataTable();             
            provider =DbProviderFactories.GetFactory("System.Data.SqlClient");  
            con = provider.CreateConnection();   //Create Connection according to Connection Class  
            con.ConnectionString = "Data Source=SOURAV-PC\\SQL_INSTANCE;Initial Catalog=test;Integrated Security=True";  
            cmd = provider.CreateCommand();   //Create command according to Provider         
            try  
            {  
                cmd.CommandText = "select * from name";  
                cmd.CommandType = CommandType.Text;  
                if (con.State == ConnectionState.Closed || con.State == ConnectionState.Broken)  
                {  
                    con.Open();  
                    cmd.Connection = con;  
                    using (con)  
                    {  
                        rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);  
                        while (rdr.Read())  
                        {  
                            Console.WriteLine(rdr["nametest"].ToString());  
                            Console.WriteLine(rdr["surname"].ToString());  
                        }  
                    }  
                }  
            }          
            catch (Exception ex)  
            {  
                throw;  
            }  
            finally  
            {  
                //trn.Rollback();  
                con.Dispose();  
                cmd.Dispose();  
            }  
            Console.ReadLine();    
        }  
    }  
}

Here is a sample output.

You can see that nowhere in the example have we written any database-specific ADO.NET code. We have used various methods of the Dbfactory class to create an object depending on Supplier. Have a look at the following code.

con = provider.CreateConnection();   //Create Connection according to database provide  
cmd = provider.CreateCommand();   //Create command according to database provider 

Here the provider is nothing but an object of the DbProviderFactory class, and we are using a function like Createconnection() and CreateCommand() to initialize a connection and command object.

Now, if you want to change the database, then change the provider name or database supplier name like:

provider =DbProviderFactories.GetFactory("System.Data.SqlClient");

Here we have provided our database provider as SQLServer, and tomorrow, if you want to, you can use MySQL; modify the code as in the following:

provider =DbProviderFactories.GetFactory("MySql.Data.SqlClient"); 

We need to change the provider name; the rest of the code will work fine. And see again, the DbProviderFactory class supplies an object depending on the user's demands, and this is the beauty of a factory class.

Conclusion

This is my best attempt to explain a Factory Design Pattern with an example and in my own words. I hope you enjoy it.

Continue reading

• Design Pattern For Beginners - Part 1: Singleton Design Pattern
• Design Pattern For Beginners - Part 2: Factory Design Pattern
• Design Pattern For Beginners - Part 3: Prototype Design Pattern
• Design Pattern For Beginners - Part 4: Decorator Design Pattern
• Design Pattern For Beginners - Part 5: Composite Design Pattern
• Design Pattern For Beginners - Part 6: Adaptor Design Pattern
• Design Pattern For Beginners - Part 7: Bridge Design Pattern
• Design Pattern For Beginners - Part 8: memento Design Pattern
• Design Pattern for Beginners - Part-9: Strategy Design Pattern
• Design Pattern for Beginners - Part-10: Observer Design Pattern
• Design Pattern For Beginners - Part 11: Implement Decouple Classes in Application