 (ht t p://csharpdocs.

com/feed/)
 (ht t ps://t wit t er.com/csharpdocs)
 (ht t ps://www.facebook.com/csharpdocs)

CSHARPDOCS.COM (ht t p://csharpdocs.com) > ADO.NET (ht t p://csharpdocs.com/cat egory/ado-net /) > Generic Dat a Access Layer in C# using
Factory Pat t ern

 Encrypt ion and Decrypt ion using RSA Algorit hm in C# (ht t p://csharpdocs.com/encrypt ion-and-decrypt ion-using-rsa-algorit hm-in-c/)

Generic Dat a Access Layer in C# using DbProviderFactories (ht t p://csharpdocs.com/generic-dat a-access-layer-in-c-using-

dbproviderfactories/) 

May 02

Generic Data Access Layer in C# using Factory Pattern

By csharpdocs (ht t p://csharpdocs.com/aut hor/csharpdocs/) in ADO.NET (ht t p://csharpdocs.com/cat egory/ado-net /), Design and
Archit ect ure (ht t p://csharpdocs.com/cat egory/designandarchit ect ure/)

Generic Data Access Layer in C# using Factory Pattern

1.   Introduction
A dat a access layer is an import ant part of any soft ware applicat ion. Typically, a large ent erprise(N-T ier) applicat ion will have one or more
dat abases to store t he dat a. On t he top of t hese dat abases t he Dat a Access Layer(DAL) is creat ed. A business layer which cont ains business
logic and classes represent s t he business domain used to communicat e wit h dat a access layer. A service layer is used to expose t he business
layer to t he client and finally some user int erface like AP.NET Web, Windows Form or Windows service.
 (ht t ps://4.bp.blogspot .com/-

t 2Uw7vHfUpI/WQfuMUEvb9I/AAAAAAAAAJQ/VAxUYu8O6eUcgQ8OgWnqf5gT 9ygCBL7FgCEw/s1600/N-T ier%2BArchit ect ure.jpg)

T his post is about how you can develop a generic dat a access layer (DAL) to access different t ypes of dat abase wit h full CRUD (Creat e, Read,
Updat e and Delet e) support using different t ype of ADO.NET object s.

2.   Overview
 
ADO.Net Provides consist ent access to dat abases like Microsoft SQL Server, Oracle as well as dat a sources exposed t hrough OLE DB and XML.
Data-sharing consumer applications can use ADO.NET to connect to these data sources and retrieve, manipulate, and update data. T he ADO.NET
classes are found in Syst em.Dat a.dll.
The ADO.NET components have been designed to factor data access from data manipulation. There are two central components of ADO.NET that
accomplish this: the  Dat aSet , and the .NET Framework data provider, which is a set of components including the  Connect ion, Command, Dat aReader,
and  Dat aAdapt er objects.
 
The ADO.NET DataSet is the core component of the disconnected architecture of ADO.NET. The DataSet is explicitly designed for data access
independent of any data source. The Dat aSet  cont ains a collect ion of one or more Dat aTable object s made up of rows and columns of dat a, as
well as primary key, foreign key, const raint , and relat ion informat ion about t he dat a in t he Dat aTable object s.
The Connect ion object provides connect ivit y to a dat a source. T he Command object enables access to dat abase commands to ret urn dat a,
modify dat a, run stored procedures, and send or ret rieve paramet er informat ion. T he Dat aReader provides a high-performance st ream of dat a
from t he dat a source. Finally, t he Dat aAdapt er provides t he bridge bet ween t he Dat aSet  object and t he dat a source.
T he Dat aAdapt er uses Command object s to execut e SQL commands at t he dat a source to bot h load t he Dat aSet  wit h dat a, and reconcile
changes made to t he dat a in t he Dat aSet  back to t he dat a source.
Database Objects:
1.    Connect ion– Establishes a connection to a specific data source
2.    Comman – Executes a command against a data source
3.    Dat aReader – Reads a forward-only, read-only stream of data from a data source.
4.    Dat aAdapt er – Populates a data set and resolves updates with the data source
Abst ract ing Dat a Access:
ADO.NET is designed around a set of generic interfaces that abstract the underlying data processing functionality. You can use these interfaces directly
to abstract your data access layer so that you can minimize the impact of changing the type of data source that you use. Abstracting data access is
extremely helpful when you are designing systems where your customer chooses the database server.
The core interfaces provided by ADO.NET are found in the System.Data namespace
 
·         IDbConnection – This is an interface for managing database connections.
·         IDbCommand – This is an interface for running SQL commands.
 ·         IDbTransaction – This is an interface for managing transactions.
·         IDataReader – This is an interface for reading data returned by a command.
·         IDataAdapter – This is an interface for channelling data to and from datasets.
 
       The following table shows the provider used to access different types of databases in ADO.NET
 
Database SQL Server Oracle OLE DB ODBC
Parameter
Data Provider SqlClient OracleClient OleDb Odbc
Namespace Syst em.Dat a.SqlClient Syst em.Dat a.OracleClient Syst em.Dat a.OleDb Syst em.Dat a.Odbc
Connection SqlConnect ion OracleConnect ion OleDbConnect ion OdbcConnect ion
Command SqlCommand OracleCommand OleDbCommand OdbcCommand
Data Adapter SqlDat aAdapt er OracleDat aAdapt er OleDbDat aAdapt er OdbcDat aAdaper
Data Parameter SqlParamet er OracleParamet er

3.   Practical Implementation

 
In t his example I have creat ed int erface IDatabaseHandler which cont ains basic funct ions required to assess dat a using ADO.NET object s like
IDbConnection, IDbCommand, IDataAdapter and IDbDataParameter We need to implement t hese int erfaces in child classes.

    Step 1: Create generic interface IDatabaseHandler

using System.Data;
namespace DataAccessHandler
{
    public interface IDatabaseHandler
    {
        IDbConnection CreateConnection();
        void CloseConnection(IDbConnectionconnection);
        IDbCommand CreateCommand(string commandText, CommandType commandType, IDbConnection connection);
        IDataAdapter CreateAdapter(IDbCommand command);
        IDbDataParameter CreateParameter(IDbCommand command);
    }
}
     Step 2: Implement IDatabaseHandler interface for different type of data access
 
1.       SQL Data Access
 
using System.Data;
using System.Data.SqlClient;
namespace DataAccessHandler
{
    public class SqlDataAccess : IDatabaseHandler
    {
        private string ConnectionString { get; set; }
        public SqlDataAccess(string connectionString)
        {
            ConnectionString = connectionString;
        }
        public IDbConnection CreateConnection()
        {
            return new SqlConnection(ConnectionString);
        }
        public void CloseConnection(IDbConnection connection)
        {
            var sqlConnection = (SqlConnection)connection;
            sqlConnection.Close();
            sqlConnection.Dispose();
        }
        public IDbCommand CreateCommand(string commandText, CommandType commandType, IDbConnection connection)
        {
            return new SqlCommand
            {
                CommandText = commandText,
                Connection = (SqlConnection)connection,
                CommandType = commandType
            };
        }
        public IDataAdapter CreateAdapter(IDbCommand command)
        {
            return new SqlDataAdapter((SqlCommand)command);
        }
        public IDbDataParameter CreateParameter(IDbCommand command)
        {
            SqlCommand SQLcommand = (SqlCommand)command;
             return SQLcommand.CreateParameter();
        }
    }
}
2.       Oracle Data Access
 
using System.Data;
using System.Data.OracleClient;
namespace DataAccessHandler
{
    public class OracleDataAccess : IDatabaseHandler
    {
        private string ConnectionString { get; set; }
        public OracleDataAccess(string connectionString)
        {
            ConnectionString = connectionString;
        }
        public IDbConnection CreateConnection()
        {
            return new OracleConnection(ConnectionString);
        }
        public void CloseConnection(IDbConnection connection)
        {
            var oracleConnection = (OracleConnection)connection;
            oracleConnection.Close();
            oracleConnection.Dispose();
        }
        public IDbCommand CreateCommand(string commandText, CommandType commandType, IDbConnection connection)
        {
            return new OracleCommand
            {
                CommandText = commandText,
                Connection = (OracleConnection)connection,
                CommandType = commandType
            };
        }
        public IDataAdapter CreateAdapter(IDbCommand command)
        {
            return new OracleDataAdapter((OracleCommand)command);
        }
        public IDbDataParameter CreateParameter(IDbCommand command)
        {
            OracleCommand SQLcommand = (OracleCommand)command;
            return SQLcommand.CreateParameter();
        }
    }
}
3.       OLEDB Data Access
 
using System.Data;
using System.Data.OleDb;
namespace DataAccessHandler
{
    public class OledbDataAccess : IDatabaseHandler
    {
        private string ConnectionString { get; set; }
        public OledbDataAccess(string connectionString)
        {
            ConnectionString = connectionString;
        }
        public IDbConnection CreateConnection()
        {
            return new OleDbConnection(ConnectionString);
        }
        public void CloseConnection(IDbConnectionconnection)
        {
            var oleDbConnection = (OleDbConnection)connection;
            oleDbConnection.Close();
            oleDbConnection.Dispose();
        }
        public IDbCommand CreateCommand(string commandText, CommandType commandType, IDbConnection connection)
        {
            return new OleDbCommand
            {
                CommandText = commandText,
                Connection = (OleDbConnection)connection,
                CommandType = commandType
            };
        }
         public IDataAdapter CreateAdapter(IDbCommand command)
        {
            return new OleDbDataAdapter((OleDbCommand)command);
        }
        public IDbDataParameter CreateParameter(IDbCommand command)
        {
            OleDbCommand SQLcommand = (OleDbCommand)command;
            return SQLcommand.CreateParameter();
        }
    }
}
4.       ODBC Data Access
 
using System.Data;
using System.Data.Odbc;
namespace DataAccessHandler
{
    public class OdbcDataAccess : IDatabaseHandler
    {
        private string ConnectionString { get; set; }
        public OdbcDataAccess(string connectionString)
        {
            ConnectionString = connectionString;
        }
        public IDbConnection CreateConnection()
        {
            return new OdbcConnection(ConnectionString);
        }
        public void CloseConnection(IDbConnection connection)
        {
            var odbcConnection = (OdbcConnection)connection;
            odbcConnection.Close();
            odbcConnection.Dispose();
        }
        public IDbCommand CreateCommand(string commandText, CommandType commandType, IDbConnection connection)
        {
            return new OdbcCommand
            {
                CommandText = commandText,
                Connection = (OdbcConnection)connection,
                CommandType = commandType
            };
        }
        public IDataAdapter CreateAdapter(IDbCommand command)
        {
            return new OdbcDataAdapter((OdbcCommand)command);
        }
        public IDbDataParameter CreateParameter(IDbCommand command)
        {
            OdbcCommand SQLcommand = (OdbcCommand)command;
            return SQLcommand.CreateParameter();
        }
    }
}
Step 3: Create separate class for parameter creation
 
I have creat ed separat e class for paramet er creat ion. T his would be useful while creat ion of paramet ers collect ion and t hese collect ions would be
passes to CRUD met hods. You can change t his as per your need.
 
Here I have creat ed different t ype of overloaded met hods to creat e paramet ers and set t heir values.
 
using System.Data;
using System.Data.OracleClient;
using System.Data.SqlClient;
using System.Data.OleDb;
using System.Data.Odbc;
namespace DataAccessHandler
{
    public class DataParameterManager
    {
        public static IDbDataParameter CreateParameter(string providerName, string name, object value, DbType dbType, ParameterDirection direction =
ParameterDirection.Input)
        {
            IDbDataParameter parameter = null;
            switch (providerName.ToLower())
            {
                case “system.data.sqlclient”:
                    returnCreateSqlParameter(name, value, dbType, direction);
                 case “system.data.oracleclient”:
                    returnCreateOracleParameter(name, value, dbType, direction);
                case “system.data.oleDb”:
                    break;
                case “system.data.odbc”:
                    break;
            }
            return parameter;
        }
        public static IDbDataParameterCreateParameter(string providerName, string name, int size, object value, DbType dbType, ParameterDirection direction =
ParameterDirection.Input)
        {
            IDbDataParameter parameter = null;
            switch (providerName.ToLower())
            {
                case “system.data.sqlclient”:
                    returnCreateSqlParameter(name, size, value, dbType, direction);
                case “system.data.oracleclient”:
                    return CreateOracleParameter(name, size, value, dbType, direction);
                case “system.data.oleDb”:
                    break;
                case “system.data.odbc”:
                    break;
            }
            return parameter;
        }
        private static IDbDataParameter CreateSqlParameter(string name, object value, DbType dbType, ParameterDirection direction)
        {
            return new SqlParameter
            {
                DbType = dbType,
                ParameterName = name,
                Direction = direction,
                Value = value
            };
        }
      
        private static IDbDataParameter CreateSqlParameter(string name, int size, object value, DbType dbType, ParameterDirection direction)
        {
            return new SqlParameter
            {
                DbType = dbType,
                Size = size,
                ParameterName = name,
                Direction = direction,
                Value = value
            };
        }
        private static IDbDataParameter CreateOracleParameter(string name, object value, DbType dbType, ParameterDirection direction)
        {
            return new OracleParameter
            {
                DbType = dbType,
                ParameterName = name,
                Direction = direction,
                Value = value
            };
        }
        private static IDbDataParameter CreateOracleParameter(string name, int size, object value, DbType dbType, ParameterDirection direction)
        {
            return new OracleParameter
            {
                DbType = dbType,
                Size = size,
                ParameterName = name,
                Direction = direction,
                Value = value
            };
        }
    }
}
Step 4: Create factory pattern class to create instance of specific database
 
T his class used to creat e inst ance of specific dat abase using provider name (ment ioned in hardcoded st rings). T his provider name is ment ioned in
t he web/app.config files and t his is must to ment ion provider det ails in config file
 
using System.Configuration;
namespace DataAccessHandler
{
     public class DatabaseHandlerFactory
    {
        private ConnectionStringSettings connectionStringSettings;
        public DatabaseHandlerFactory(string connectionStringName)
        {
            connectionStringSettings = ConfigurationManager.ConnectionStrings[connectionStringName];
        }
        public IDatabaseHandler CreateDatabase()
        {
            IDatabaseHandler database = null;
            switch (connectionStringSettings.ProviderName.ToLower())
            {
                case “system.data.sqlclient”:
                    database = new SqlDataAccess(connectionStringSettings.ConnectionString);
                        break;
                case “system.data.oracleclient”:
                        database = new OracleDataAccess(connectionStringSettings.ConnectionString);
                        break;
                case “system.data.oleDb”:
                        database = new OledbDataAccess(connectionStringSettings.ConnectionString);
                        break;
                case “system.data.odbc”:
                        database = new OdbcDataAccess(connectionStringSettings.ConnectionString);
                        break;
            }
            return database;
        }
        public string GetProviderName()
        {
            return connectionStringSettings.ProviderName;
        }
    }
}
Step 5: Create wrapper class to access database specific functions
 
In t his class t he const ructor of wrapper class creat es will creat e inst ance of DatabaseHandlerFactory class and will set t he ConnectionStringSettings
propert y which cont ains t he dat abase connect ion st ring and name of provider. Lat er call t he Creat eDat abase() funct ion of
DatabaseHandlerFactoryclass to creat e dat abase specific inst ance.
Now, creat e t he CRUD funct ions to ret urn ADO.NET object s like Dat aTable, Dat aSet , Dat aReader and Scalar values. T hese funct ions int ernally call
base funct ions to creat e Dat abase connect ion, Commands and Dat aAdapt ers. T his wrapper class cont ains different overloads to support more
funct ionalit y and dat abase t ransact ions as well.
using System;
using System.Data;
namespace DataAccessHandler
{
    public class DBManager
    {
        private DatabaseHandlerFactory dbFactory;
        private IDatabaseHandler database;
        private string providerName;
        public DBManager(string connectionStringName)
        {
            dbFactory = new DatabaseHandlerFactory(connectionStringName);
            database = dbFactory.CreateDatabase();
            providerName = dbFactory.GetProviderName();
        }
        public IDbConnection GetDatabasecOnnection()
        {
            return database.CreateConnection();
        }
       
        public void CloseConnection(IDbConnectionconnection)
        {
            database.CloseConnection(connection);
        }
        public IDbDataParameter CreateParameter(string name, object value, DbType dbType)
        {
            return DataParameterManager.CreateParameter(providerName, name, value, dbType, ParameterDirection.Input);
        }
        public IDbDataParameter CreateParameter(string name, int size, object value, DbType dbType)
        {
            return DataParameterManager.CreateParameter(providerName, name, size, value, dbType, ParameterDirection.Input);
        }
        public IDbDataParameter CreateParameter(string name, int size, object value, DbType dbType, ParameterDirection direction)
        {
            return DataParameterManager.CreateParameter(providerName, name, size, value, dbType, direction);
        }
        public DataTable GetDataTable(string commandText, CommandType commandType, IDbDataParameter[] parameters = null)
        {
            using (var connection = database.CreateConnection())
            {
                connection.Open();
                using (var command = database.CreateCommand(commandText, commandType, connection))
                {
                    if (parameters != null)
                    {
                        foreach (var parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }
                    var dataset = new DataSet();
                    var dataAdaper = database.CreateAdapter(command);
                    dataAdaper.Fill(dataset);
                    return dataset.Tables[0];
                }
            }
        }
        public DataSet GetDataSet(string commandText, CommandType commandType, IDbDataParameter[] parameters = null)
        {
            using (var connection = database.CreateConnection())
            {
                connection.Open();
                using (var command = database.CreateCommand(commandText, commandType, connection))
                {
                    if (parameters != null)
                    {
                        foreach (var parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }
                    var dataset = new DataSet();
                    var dataAdaper = database.CreateAdapter(command);
                    dataAdaper.Fill(dataset);
                    return dataset;
                }
            }
        }
        public IDataReader GetDataReader(string commandText, CommandType commandType, IDbDataParameter[] parameters, out IDbConnection
connection)
        {
            IDataReader reader = null;
            connection = database.CreateConnection();
            connection.Open();
            var command = database.CreateCommand(commandText, commandType, connection);
            if (parameters != null)
            {
                foreach (var parameter in parameters)
                {
                    command.Parameters.Add(parameter);
                }
            }
            reader = command.ExecuteReader();
           
            return reader;
        }
        public void Delete(string commandText, CommandType commandType, IDbDataParameter[] parameters = null)
        {
            using (var connection = database.CreateConnection())
            {
                connection.Open();
                using (var command = database.CreateCommand(commandText, commandType, connection))
                {
                    if (parameters != null)
                    {
                        foreach (var parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }
                    command.ExecuteNonQuery();
                }
            }
        }
        public void Insert(string commandText, CommandType commandType, IDbDataParameter[] parameters)
        {
            using (var connection = database.CreateConnection())
            {
                connection.Open();
                using (var command = database.CreateCommand(commandText, commandType, connection))
                {
                    if (parameters != null)
                    {
                        foreach (var parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }
                    command.ExecuteNonQuery();
                }
            }
        }
        public int Insert(string commandText, CommandType commandType, IDbDataParameter[] parameters, out int lastId)
        {
            lastId = 0;
            using (var connection = database.CreateConnection())
            {
                connection.Open();
                using (var command = database.CreateCommand(commandText, commandType, connection))
                {
                    if (parameters != null)
                    {
                        foreach (var parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }
                    object newId = command.ExecuteScalar();
                    lastId = Convert.ToInt32(newId);
                }
            }
            return lastId;
        }
        public long Insert(string commandText, CommandType commandType, IDbDataParameter[] parameters, out long lastId)
        {
            lastId = 0;
            using (var connection = database.CreateConnection())
            {
                connection.Open();
                using (var command = database.CreateCommand(commandText, commandType, connection))
                {
                    if (parameters != null)
                    {
                        foreach (var parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }
                    object newId = command.ExecuteScalar();
                    lastId = Convert.ToInt64(newId);
                }
            }
            return lastId;
        }
        public void InsertWithTransaction(string commandText, CommandType commandType, IDbDataParameter[] parameters)
        {
            IDbTransaction transactionScope = null;
            using (var connection = database.CreateConnection())
            {
                connection.Open();
                transactionScope = connection.BeginTransaction();
                using (var command = database.CreateCommand(commandText, commandType, connection))
                {
                    if (parameters != null)
                    {
                        foreach (var parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }
                    try
                    {
                        command.ExecuteNonQuery();
                        transactionScope.Commit();
                    }
                    catch (Exception)
                    {
                        transactionScope.Rollback();
                    }
                    finally
                    {
                        connection.Close();
                    }
                }
            }
        }
        public void InsertWithTransaction(string commandText, CommandType commandType, IsolationLevel isolationLevel, IDbDataParameter[] parameters)
        {
            IDbTransaction transactionScope = null;
            using (var connection = database.CreateConnection())
            {
                connection.Open();
                transactionScope = connection.BeginTransaction(isolationLevel);
                using (var command = database.CreateCommand(commandText, commandType, connection))
                {
                    if (parameters != null)
                    {
                        foreach (var parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }
                    try
                    {
                        command.ExecuteNonQuery();
                        transactionScope.Commit();
                    }
                    catch (Exception)
                    {
                        transactionScope.Rollback();
                    }
                    finally
                    {
                        connection.Close();
                    }
                }
            }
        }
        public void Update(string commandText, CommandType commandType, IDbDataParameter[] parameters)
        {
            using (var connection = database.CreateConnection())
            {
                connection.Open();
                using (var command = database.CreateCommand(commandText, commandType, connection))
                {
                    if (parameters != null)
                    {
                        foreach (var parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }
                    command.ExecuteNonQuery();
                }
            }
        }
        public void UpdateWithTransaction(string commandText, CommandType commandType, IDbDataParameter[] parameters)
        {
            IDbTransaction transactionScope = null;
            using (var connection = database.CreateConnection())
            {
                connection.Open();
                transactionScope = connection.BeginTransaction();
                using (var command = database.CreateCommand(commandText, commandType, connection))
                {
                    if (parameters != null)
                    {
                        foreach (var parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }
                    try
                    {
                        command.ExecuteNonQuery();
                        transactionScope.Commit();
                    }
                     catch (Exception)
                    {
                        transactionScope.Rollback();
                    }
                    finally
                    {
                        connection.Close();
                    }
                }
            }
        }
        public void UpdateWithTransaction(string commandText, CommandType commandType, IsolationLevel isolationLevel, IDbDataParameter[] parameters)
        {
            IDbTransaction transactionScope = null;
            using (var connection = database.CreateConnection())
            {
                connection.Open();
                transactionScope = connection.BeginTransaction(isolationLevel);
                using (var command = database.CreateCommand(commandText, commandType, connection))
                {
                    if (parameters != null)
                    {
                        foreach (var parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }
                    try
                    {
                        command.ExecuteNonQuery();
                        transactionScope.Commit();
                    }
                    catch (Exception)
                    {
                        transactionScope.Rollback();
                    }
                    finally
                    {
                        connection.Close();
                    }
                }
            }
        }
        public object GetScalarValue(string commandText, CommandType commandType, IDbDataParameter[] parameters= null)
        {
            using (var connection = database.CreateConnection())
            {
                connection.Open();
                using (var command = database.CreateCommand(commandText, commandType, connection))
                {
                    if (parameters != null)
                    {
                        foreach (var parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }
                    returncommand.ExecuteScalar();
                }
            }
        }
    }
}
Step 5: Test the wrapper class using console application
 
First creat e t he class specific to User t able in dat abase. We will use t his class to Insert and Updat e and Delet e funct ionalit ies.
using System;
namespace DataAccessHandler.ConsoleApp
{
    public class User
    {
        public int Id { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public DateT ime Dob { get; set; }
        public bool IsActive { get; set; }
    }
}
Now, creat e t he program to t est wrapper class. Here we will creat e inst ance of DBManager class by passing connect ion st ring name only.
using System;
using System.Data;
using System.Collections.Generic;
namespace DataAccessHandler.ConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(“================ Using Database Factory =================nnn”);
            UsingDatabaseFactory();
            Console.ReadKey();
        }
        private static void UsingDatabaseFactory()
        {
            var dbManager = new DBManager(“DBConnection”);
            var user = new User
            {
                FirstName = “First”,
                LastName = “Last”,
                Dob = DateT ime.Now.AddDays(-3000),
                IsActive = true
            };
            var parameters = new List<IDbDataParameter>();
            parameters.Add(dbManager.CreateParameter(“@FirstName”, 50, user.FirstName, DbType.String));
            parameters.Add(dbManager.CreateParameter(“@LastName”, user.LastName, DbType.String));
            parameters.Add(dbManager.CreateParameter(“@Dob”, user.Dob, DbType.DateT ime));
            parameters.Add(dbManager.CreateParameter(“@IsActive”, 50, user.IsActive, DbType.Boolean));
            //INSERT
            int lastId = 0;
            dbManager.Insert(“DAH_User_Insert”, CommandType.StoredProcedure, parameters.ToArray(), out lastId);
            Console.WriteLine(“nINSERT ED ID: “ + lastId);
            //DATATABLE
            var dataTable = dbManager.GetDataTable(“DAH_User_GetAll”, CommandType.StoredProcedure);
            Console.WriteLine(“nT OTAL ROWS IN TABLE: “ + dataTable.Rows.Count);
            //DATAREADER
            IDbConnection connection = null;
            var dataReader = dbManager.GetDataReader(“DAH_User_GetAll”, CommandType.StoredProcedure, null, out connection);
            try
            {
                user = new User();
                while (dataReader.Read())
                {
                    user.FirstName = dataReader[“FirstName”].ToString();
                    user.LastName = dataReader[“LastName”].ToString();
                }
                Console.WriteLine(string.Format(“nDATA READER VALUES FirstName: {0} LastName: {1}”, user.FirstName, user.LastName));
            }
            catch (Exception)
            {
                
            }
            finally
            {
                dataReader.Close();
                dbManager.CloseConnection(connection);
            }
            //SCALAR
            object scalar = dbManager.GetScalarValue(“DAH_User_Scalar”, CommandType.StoredProcedure);
            Console.WriteLine(“nSCALAR VALUE: “ + scalar.ToString());
            //UPDAT E
            user = new User
            {
                Id = lastId,
                FirstName = “First1”,
                LastName = “Last1”,
                Dob = DateT ime.Now.AddDays(-5000)
            };
            parameters = new List<IDbDataParameter>();
            parameters.Add(dbManager.CreateParameter(“@Id”, user.Id, DbType.Int32));
            parameters.Add(dbManager.CreateParameter(“@FirstName”, 50, user.FirstName, DbType.String));
            parameters.Add(dbManager.CreateParameter(“@LastName”, user.LastName, DbType.String));
            parameters.Add(dbManager.CreateParameter(“@Dob”, user.Dob, DbType.DateT ime));
            dbManager.Update(“DAH_User_Update”, CommandType.StoredProcedure, parameters.ToArray());
            //DATATABLE
            dataTable = dbManager.GetDataTable(“DAH_User_GetAll”, CommandType.StoredProcedure);
            Console.WriteLine(string.Format(“nUPADT ED VALUES FirstName: {0} LastName: {1}”, dataTable.Rows[0][“FirstName”].ToString(), dataTable.Rows[0]
[“LastName”].ToString()));
            //DELET E
            parameters = new List<IDbDataParameter>();
             parameters.Add(dbManager.CreateParameter(“@Id”, user.Id, DbType.Int32));
            dbManager.Delete(“DAH_User_Delete”, CommandType.StoredProcedure, parameters.ToArray());
            Console.WriteLine(“nDELET ED RECORD FOR ID: “ + user.Id);
            //DATATABLE
            dataTable = dbManager.GetDataTable(“DAH_User_GetAll”, CommandType.StoredProcedure);
            Console.WriteLine(“nT OTAL ROWS IN TABLE: “ + dataTable.Rows.Count);
        }
    }
}
Step 6: Output of Console Application

(ht t ps://4.bp.blogspot .com/-

qIqcmefXqWU/WQfuMVznrbI/AAAAAAAAAJQ/WIYJyuGt i8UDq4Biok2Lf9eaULZU3W_ GACEw/s1600/UsingDBFactory.jpg)

4.   Summary
In t his art icle I have explained how to creat e generic dat a access layer in C# using factory pat t ern. In t his post we creat ed separat e classes for
each t ype of dat abase and hence it increased t he complexit y as well. Microsoft has also provided t he DbProviderFactory class in
System.Data.Common namespace. T his class is uses to creat e inst ance for specific provider and t his inst ance is used to creat e funct ions like
CreateParameter, CreateDataAdapter, CreateCommand and CreateConnection. In my next (ht t p://csharpdocs.com/generic-dat a-access-layer-in-c-
using-dbproviderfactories/) post I will show you how DBManager class will use DbProviderFactoryclass to creat e inst ances of different dat abases.
hope you enjoyed t his art icle. If you like t his art icle don’t forget to put your valuable comment s.

5.   Download Code

Click here (ht t ps://drive.google.com/open?id=0B4Aj7Mrx7FZ8ZnN5RGJkXzVpMXc)to download t he source code of t his art icle.

 ADO.NET (ht t p://csharpdocs.com/t ag/ado-net /), Dat a Access Layer (ht t p://csharpdocs.com/t ag/dat a-access-layer/), Factory
Pat t ern (ht t p://csharpdocs.com/t ag/factory-pat t ern/)

(ht t p://csharpdocs.com/aut hor/csharpdocs/)

csharpdocs
 (mailto:onlinerohit [email protected])

 1 comment
1.
coolc () on August 27, 2019

Log in to Reply (http://csharpdocs.com/wp-login.php?redirect_to=https%3A%2F%2Fround-lake.dustinice.workers.dev%3A443%2Fhttp%2Fcsharpdocs.com%2Fgeneric-data-access-layer-in-c-using-factory-pattern%2F)

 nice work, when i t ried implement ing, it requires me to have a dat abase assemblies loaded, i need to use just one at a t ime wit hout
having to load all dat abase assemblies, how would i do t his?

Leave a Reply
You must be logged in (ht t p://csharpdocs.com/wp-login.php?redirect _ to=ht t p%3A%2F%2Fcsharpdocs.com%2Fgeneric-dat a-access-layer-in-c-
using-factory-pat t ern%2F) to post a comment .

Recent Posts
How to Call Stored Procedure using Unit of Work and Ent it y Framework (ht t p://csharpdocs.com/how-to-call-stored-procedure-using-unit -of-
work-and-ent it y-framework/)
A reference guide to access dat a in .Net (ht t p://csharpdocs.com/a-reference-guide-to-access-dat a-in-net /)
Tech News: Microsoft has released in .NET Framework 4.7.2 (ht t p://csharpdocs.com/t ech-news-what s-new-in-net -framework-4-7-2/)
Microsoft Cert ificat ion Roadmap for Developers (ht t p://csharpdocs.com/microsoft -cert ificat ion-roadmap-for-developers/)
How to call stored procedure using repository pat t ern and unit of work (ht t p://csharpdocs.com/call-stored-procedure-using-repository-
pat t ern/)

Categories
.NET Core (ht t p://csharpdocs.com/cat egory/web-t echnology/net -core/) (1)
ADO.NET (ht t p://csharpdocs.com/cat egory/ado-net /) (10)
AngularJS (ht t p://csharpdocs.com/cat egory/javascript /angular-js/) (1)
Art icles (ht t p://csharpdocs.com/cat egory/ot her/art icles/) (2)
ASP.NET MVC (ht t p://csharpdocs.com/cat egory/web-t echnology/asp-net -mvc/) (8)
Best Pract ices (ht t p://csharpdocs.com/cat egory/designandarchit ect ure/best -pract ices/) (2)
C# (ht t p://csharpdocs.com/cat egory/c/) (7)
Chart s (ht t p://csharpdocs.com/cat egory/web-t echnology/chart s/) (6)
Design and Archit ect ure (ht t p://csharpdocs.com/cat egory/designandarchit ect ure/) (3)
Ent it y Framework (ht t p://csharpdocs.com/cat egory/ado-net /ent it y-framework/) (5)
Int erview Quest ions (ht t p://csharpdocs.com/cat egory/ot her/int erview-quest ions/) (11)
Javascript (ht t p://csharpdocs.com/cat egory/javascript /) (2)
jQuery (ht t p://csharpdocs.com/cat egory/javascript /jquery/) (2)
Ot her (ht t p://csharpdocs.com/cat egory/ot her/) (3)
Performance Opt imizat ion (ht t p://csharpdocs.com/cat egory/designandarchit ect ure/performance-opt imizat ion/) (1)
Securit y (ht t p://csharpdocs.com/cat egory/securit y/) (1)
SQL Server (ht t p://csharpdocs.com/cat egory/sql-server/) (35)
Tech News (ht t p://csharpdocs.com/cat egory/ot her/t ech-news/) (1)
Tutorials (ht t p://csharpdocs.com/cat egory/t utorials/) (3)
WCF (ht t p://csharpdocs.com/cat egory/web-services/wcf/) (2)
Web API (ht t p://csharpdocs.com/cat egory/web-services/web-api/) (1)
Web Services (ht t p://csharpdocs.com/cat egory/web-services/) (3)
Web Technology (ht t p://csharpdocs.com/cat egory/web-t echnology/) (9)

Subscribe Me
Name

Email *

Subscribe

Contact Us
Name *
First Last

E-mail *

Comment or Message *

Submit

Categories
.NET Core (ht t p://csharpdocs.com/cat egory/web-t echnology/net -core/) (1)
ADO.NET (ht t p://csharpdocs.com/cat egory/ado-net /) (10)
AngularJS (ht t p://csharpdocs.com/cat egory/javascript /angular-js/) (1)
Art icles (ht t p://csharpdocs.com/cat egory/ot her/art icles/) (2)
ASP.NET MVC (ht t p://csharpdocs.com/cat egory/web-t echnology/asp-net -mvc/) (8)
Best Pract ices (ht t p://csharpdocs.com/cat egory/designandarchit ect ure/best -pract ices/) (2)
C# (ht t p://csharpdocs.com/cat egory/c/) (7)
Chart s (ht t p://csharpdocs.com/cat egory/web-t echnology/chart s/) (6)
Design and Archit ect ure (ht t p://csharpdocs.com/cat egory/designandarchit ect ure/) (3)
Ent it y Framework (ht t p://csharpdocs.com/cat egory/ado-net /ent it y-framework/) (5)
Int erview Quest ions (ht t p://csharpdocs.com/cat egory/ot her/int erview-quest ions/) (11)
Javascript (ht t p://csharpdocs.com/cat egory/javascript /) (2)
jQuery (ht t p://csharpdocs.com/cat egory/javascript /jquery/) (2)
Ot her (ht t p://csharpdocs.com/cat egory/ot her/) (3)
Performance Opt imizat ion (ht t p://csharpdocs.com/cat egory/designandarchit ect ure/performance-opt imizat ion/) (1)
Securit y (ht t p://csharpdocs.com/cat egory/securit y/) (1)
SQL Server (ht t p://csharpdocs.com/cat egory/sql-server/) (35)
Tech News (ht t p://csharpdocs.com/cat egory/ot her/t ech-news/) (1)
Tutorials (ht t p://csharpdocs.com/cat egory/t utorials/) (3)
WCF (ht t p://csharpdocs.com/cat egory/web-services/wcf/) (2)
Web API (ht t p://csharpdocs.com/cat egory/web-services/web-api/) (1)
Web Services (ht t p://csharpdocs.com/cat egory/web-services/) (3)
Web Technology (ht t p://csharpdocs.com/cat egory/web-t echnology/) (9)

Tags
Action Filters (1) (http://csharpdocs.com/tag/action-filters/) ADO.NET (7) (http://csharpdocs.com/tag/ado-net/) Articles (3)
(http://csharpdocs.com/tag/articles/) Bar Chart (1) (http://csharpdocs.com/tag/bar-chart/) Best Practices of SQL Dployment (1) (http://csharpdocs.com/tag/best-practices-of-sql-
dployment/) Charts in MVC (2) (http://csharpdocs.com/tag/charts-in-mvc/) Coding Standards (1) (http://csharpdocs.com/tag/coding-standards/) Column Chart (1)
(http://csharpdocs.com/tag/column-chart/) Data Access Layer (4) (http://csharpdocs.com/tag/data-access-layer/) Dependency Injection (1)
(http://csharpdocs.com/tag/dependency-injection/) Deployment Script (1) (http://csharpdocs.com/tag/deployment-script/) Development Best Practices (1) (http://csharpdocs.com/tag/development-best-

practices/) Development Stack (2) (http://csharpdocs.com/tag/development-stack/) Donut Chart (1) (http://csharpdocs.com/tag/donut-chart/) Emails in C# (1)
(http://csharpdocs.com/tag/emails-in-c/) Encryption and Decryption (1) (http://csharpdocs.com/tag/encryption-and-decryption/) Entity Framework (5)
(http://csharpdocs.com/tag/entity-framework/) Export to CSV (1) (http://csharpdocs.com/tag/export-to-csv/) Export to Excel (1) (http://csharpdocs.com/tag/export-to-
excel/) Export to PDF (1) (http://csharpdocs.com/tag/export-to-pdf/) Export to Word (1) (http://csharpdocs.com/tag/export-to-word/) Factory Pattern (1) (http://csharpdocs.com/tag/factory-pattern/) Generic

Google Visualization Charts (3)

Ajax (1) (http://csharpdocs.com/tag/generic-ajax/) Generic Repository Pattern (1) (http://csharpdocs.com/tag/generic-repository-pattern/)

(http://csharpdocs.com/tag/google- visualization- charts/) GZip (1) (http://csharpdocs.com/tag/gzip/) HighCharts (1) (http://csharpdocs.com/tag/highcharts/)

Interview Questions (11) (http://csharpdocs.com/tag/interview-questions/) jQuery (2)
(http://csharpdocs.com/tag/jquery/) LINQ to SQL (1) (http://csharpdocs.com/tag/linq-to-sql/) MIME Types (1) (http://csharpdocs.com/tag/mime-types/) MVC Charts (1)
(http://csharpdocs.com/tag/mvc-charts/) Object Relationship Mapper (1) (http://csharpdocs.com/tag/object-relationship-mapper/) Organization Chart (1) (http://csharpdocs.com/tag/organization-chart/)

Pie Chart (1) (http://csharpdocs.com/tag/pie-chart/) RSA Algorithm (1) (http://csharpdocs.com/tag/rsa-algorithm/) Security (1) (http://csharpdocs.com/tag/security/) Send email (1)

(http://csharpdocs.com/tag/send-email/) Session in .NET Core (1) (http://csharpdocs.com/tag/session-in-net-core/) SQL Joins (8)

SQL S (33)
 (http://csharpdocs.com/tag/sql-joins/) SQL
Server (33)
(http://csharpdocs.com/tag/sql-server/) Tree View (1) (http://csharpdocs.com/tag/tree-view/) Tutorials (2)
(http://csharpdocs.com/tag/tutorials/) U nit Of Work (1) (http://csharpdocs.com/tag/unit-of-work/) WCF (2) (http://csharpdocs.com/tag/wcf/)

Recent Posts
How to Call Stored Procedure using Unit of Work and Ent it y Framework (ht t p://csharpdocs.com/how-to-call-stored-procedure-using-unit -of-
work-and-ent it y-framework/)
A reference guide to access dat a in .Net (ht t p://csharpdocs.com/a-reference-guide-to-access-dat a-in-net /)
Tech News: Microsoft has released in .NET Framework 4.7.2 (ht t p://csharpdocs.com/t ech-news-what s-new-in-net -framework-4-7-2/)
Microsoft Cert ificat ion Roadmap for Developers (ht t p://csharpdocs.com/microsoft -cert ificat ion-roadmap-for-developers/)
How to call stored procedure using repository pat t ern and unit of work (ht t p://csharpdocs.com/call-stored-procedure-using-repository-
pat t ern/)
WCF Beginners – St ep by st ep WCF approach (ht t p://csharpdocs.com/wcf-beginners-st ep-by-st ep-wcf-implement at ion/)
St udent Course Inst ructor based SQL Queries (ht t p://csharpdocs.com/st udent -course-inst ructor-based-sql-int erview-queries/)
St udent Course Inst ructor based SQL Int erview Quest ions (ht t p://csharpdocs.com/st udent -course-inst ructor-int erview-quest ions/)
Frequent ly asked SQL Queries in Int erviews (ht t p://csharpdocs.com/frequent ly-asked-sql-queries-in-int erviews/)
Sort ing, Filt ering, Searching and Paginat ion using SQL Stored Procedure (ht t p://csharpdocs.com/sort ing-filt ering-searching-paginat ion-
using-sql-stored-procedure/)
SQL Triggers (ht t p://csharpdocs.com/sql-t riggers/)
SQL Funct ions (ht t p://csharpdocs.com/sql-funct ions/)

© 2019 CSHARPDOCS.COM.

Made wit h  by Graphene T hemes (ht t ps://www.graphene-t heme.com/).