LOGIN DAL

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.SqlClient;
using HRHO_Entities;
using HRHO_Utilities;
using System.Configuration;
namespace HRHO_DAL
{
    class LoginDAL:DataProviderBase
    {
        public List<LoginProperty> Getloginval(string uname, string pwd, string ipaddr)
        {
            string a = "";
            string b = "";
            List<LoginProperty> Stlogin = new List<LoginProperty>();
            IDBManager dbManager = new DBManager(base.GetProvider(), ConfigurationManager.AppSettings["connection"].ToString());
            DataSet dS = new DataSet();
            DataTable dT = new DataTable();
            try
            {
                dbManager.Open();
                dbManager.CreateParameters(3);
                dbManager.AddParameters(0, "@uname", uname);
                dbManager.AddParameters(1, "@pwd", pwd);
                dbManager.AddParameters(2, "@IP_ADDR", ipaddr);
                dS = dbManager.ExecuteDataSet(CommandType.StoredProcedure, "Getloginval");

                if (dS.Tables.Count > 0)
                {

                    LoginProperty stl = new LoginProperty();
                    foreach (DataRow Dr in dS.Tables[0].Rows)
                    {


                        stl.firstName = Convert.ToString(Dr["firstName"]);
                        //b = Convert.ToString(Dr["firstName"]);
                        stl.userType = Convert.ToInt32(Dr["userType"]);

                        Stlogin.Add(stl);
                    }

                }
                else
                {

                    return Stlogin;
                }

                return Stlogin;
            }
            catch (Exception er)
            {
                throw;
            }

        }
    }
}

DAL DataProviderBase

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Configuration;
using HRHO_Utilities;
namespace HRHO_DAL
{
    public abstract class DataProviderBase
    {


        protected DataProvider GetProvider()
        {
            DataProvider prov;


            switch (ConfigurationManager.AppSettings["DataProvider"].ToString())
            {
                case "Odbc":
                    prov = DataProvider.Odbc;
                    break;
                case "OleDb":
                    prov = DataProvider.OleDb;
                    break;
                case "Oracle":
                    prov = DataProvider.Oracle;
                    break;
                default:
                    prov = DataProvider.SqlServer;
                    break;
            }

            return prov;
        }

    }
}

Entities

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace HRHO_Entities
{
    public class CountryEntities
    {
        #region
        public int ID { get; set; }
        public string Name { get; set; }
        public string CountryCode { get; set; }
        public int companyId { get; set; }
        public int flag { get; set; }
        //public int companyId { get; set; }
       
        #endregion
    }
}

DBManager

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.SqlClient;
namespace HRHO_Utilities
{

    /// <summary>
    /// This enum contains all the DataProvider types supported by the DBManager
    /// </summary>
    public enum DataProvider
    {
        Oracle, SqlServer, OleDb, Odbc
    }

    public interface IDBManager
    {
        /// <summary>
        /// Get or set Data Provider type
        /// </summary>
        DataProvider ProviderType
        {
            get;
            set;
        }

        /// <summary>
        /// Get or set connection string
        /// </summary>
        string ConnectionString
        {
            get;
            set;
        }

        /// <summary>
        /// Get connection object
        /// </summary>
        IDbConnection Connection
        {
            get;
        }

        /// <summary>
        /// Get transaction object
        /// </summary>
        IDbTransaction Transaction
        {
            get;
        }

        /// <summary>
        /// Get or set DataReader object
        /// </summary>
        IDataReader DataReader
        {
            get;
            set;
        }

        /// <summary>
        /// Get command object
        /// </summary>
        IDbCommand Command
        {
            get;
        }

        /// <summary>
        /// Get parameter array
        /// </summary>
        IDbDataParameter[] Parameters
        {
            get;
        }

        /// <summary>
        /// This method can be used to establish (open) a new connection with the data source.
        /// </summary>
        void Open();

        /// <summary>
        /// This method can be used to begin (start) an ADO.NET transaction.
        /// </summary>
        void BeginTransaction();

        /// <summary>
        /// This method can be used to commit (end) an ADO.NET transaction.
        /// </summary>
        void CommitTransaction();

        /// <summary>
        /// This method can be used to initialise 'n' number of parameters.
        /// </summary>
        /// <param name="paramsCount">Number of parameters to initialise</param>
        void CreateParameters(int paramsCount);

        /// <summary>
        /// This method can be used to add a parameter to already initialised parameter object.
        /// </summary>
        /// <param name="index">Index of the parameter object</param>
        /// <param name="paramName">Parameter name (as given in the T-SQL)</param>
        /// <param name="objValue">Parameter value</param>
        void AddParameters(int index, string paramName, object objValue);

        /// <summary>
        /// This method can be used to add a parameter to already initialised parameter object.
        /// </summary>
        /// <param name="index">Index of the parameter object</param>
        /// <param name="paramName">Parameter name (as given in the T-SQL)</param>
        /// <param name="objValue">Parameter value</param>
        /// <param name="direction">Parameter direction (can be Input, OutPut and InputOutPut)</param>
        void AddParameters(int index, string paramName, object objValue, ParameterDirection direction);

        /// <summary>
        /// This method can be used to add a parameter to already initialised parameter object.
        /// </summary>
        /// <param name="index">Index of the parameter object</param>
        /// <param name="paramName">Parameter name (as given in the T-SQL)</param>
        /// <param name="objValue">Parameter value</param>
        /// <param name="type">Parameter type</param>
        /// <param name="size">Size of the parameter</param>
        /// <param name="direction">Parameter direction (can be Input, OutPut and InputOutPut)</param>
        void AddParameters(int index, string paramName, object objValue, DbType type, int size, ParameterDirection direction);

        /// <summary>
        /// This method can be used to execute an ADO.NET DataReader.
        /// </summary>
        /// <param name="commandType">Command type (can be Text or Stored Procedure)</param>
        /// <param name="commandText">Command text (can be T-SQL statement or Stored Procedure name)</param>
        /// <returns>Returns an ADO.NET DataReader object</returns>
        IDataReader ExecuteReader(CommandType commandType, string commandText);

        /// <summary>
        /// This method can be used to fetch an ADO.NET DataSet.
        /// </summary>
        /// <param name="commandType">Command type (can be Text or Stored Procedure)</param>
        /// <param name="commandText">Command text (can be T-SQL statement or Stored Procedure name)</param>
        /// <returns>Returns an ADO.NET DataSet object</returns>
        DataSet ExecuteDataSet(CommandType commandType, string commandText);

        /// <summary>
        /// This method can be used to fetch a Scalar value.
        /// </summary>
        /// <param name="commandType">Command type (can be Text or Stored Procedure)</param>
        /// <param name="commandText">Command text (can be T-SQL statement or Stored Procedure name)</param>
        /// <returns>Returns a scalar value as object</returns>
        object ExecuteScalar(CommandType commandType, string commandText);

        /// <summary>
        /// This method can be used to execute a T-SQL statement.
        /// </summary>
        /// <param name="commandType">Command type (can be Text or Stored Procedure)</param>
        /// <param name="commandText">Command text (can be T-SQL statement or Stored Procedure name)</param>
        /// <returns>Returns the number of Rows affected by the statement</returns>
        int ExecuteNonQuery(CommandType commandType, string commandText);

        /// <summary>
        /// This method can be used to close an already oppened DataReader object.
        /// </summary>
        void CloseReader();
        void SQLBulkInsert(DataTable dt, string tableName);

        /// <summary>
        /// This method can be used to close an already oppened Connection object.
        /// </summary>
        void Close();

        /// <summary>
        /// This method will deallocate all the resources allocated to the DBManager object.
        /// </summary>
        void Dispose();

    }  

}

DBManagerFactory

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.SqlClient;
using System.Data.OleDb;
using System.Data.Odbc;
using System.Data.OracleClient;
namespace HRHO_Utilities
{
    public sealed class DBManagerFactory
    {
        private DBManagerFactory() { }

        public static IDbConnection GetConnection(DataProvider providerType)
        {
            IDbConnection iDbConnection = null;
            switch (providerType)
            {
                case DataProvider.SqlServer:
                    iDbConnection = new SqlConnection();
                    break;
                case DataProvider.OleDb:
                    iDbConnection = new OleDbConnection();
                    break;
                case DataProvider.Odbc:
                    iDbConnection = new OdbcConnection();
                    break;
                case DataProvider.Oracle:
                    iDbConnection = new OracleConnection();
                    break;
                default:
                    return null;
            }
            return iDbConnection;
        }

        public static IDbCommand GetCommand(DataProvider providerType)
        {
            switch (providerType)
            {
                case DataProvider.SqlServer:
                    return new SqlCommand();
                case DataProvider.OleDb:
                    return new OleDbCommand();
                case DataProvider.Odbc:
                    return new OdbcCommand();
                case DataProvider.Oracle:
                    return new OracleCommand();
                default:
                    return null;
            }
        }

        public static IDbDataAdapter GetDataAdapter(DataProvider providerType)
        {
            switch (providerType)
            {
                case DataProvider.SqlServer:
                    return new SqlDataAdapter();
                case DataProvider.OleDb:
                    return new OleDbDataAdapter();
                case DataProvider.Odbc:
                    return new OdbcDataAdapter();
                case DataProvider.Oracle:
                    return new OracleDataAdapter();
                default:
                    return null;
            }
        }

        public static IDbTransaction GetTransaction(DataProvider providerType)
        {
            IDbConnection iDbConnection = GetConnection(providerType);
            IDbTransaction iDbTransaction = iDbConnection.BeginTransaction();
            return iDbTransaction;
        }

        public static IDataParameter GetParameter(DataProvider providerType)
        {
            IDataParameter iDataParameter = null;
            switch (providerType)
            {
                case DataProvider.SqlServer:
                    iDataParameter = new SqlParameter();
                    break;
                case DataProvider.OleDb:
                    iDataParameter = new OleDbParameter();
                    break;
                case DataProvider.Odbc:
                    iDataParameter = new OdbcParameter();
                    break;
                case DataProvider.Oracle:
                    iDataParameter = new OracleParameter();
                    break;

            }
            return iDataParameter;
        }

        public static IDbDataParameter[] GetParameters(DataProvider providerType, int paramsCount)
        {
            IDbDataParameter[] idbParams = new IDbDataParameter[paramsCount];

            switch (providerType)
            {
                case DataProvider.SqlServer:
                    for (int i = 0; i < paramsCount; ++i)
                    {
                        idbParams[i] = new SqlParameter();
                    }
                    break;
                case DataProvider.OleDb:
                    for (int i = 0; i < paramsCount; ++i)
                    {
                        idbParams[i] = new OleDbParameter();
                    }
                    break;
                case DataProvider.Odbc:
                    for (int i = 0; i < paramsCount; ++i)
                    {
                        idbParams[i] = new OdbcParameter();
                    }
                    break;
                case DataProvider.Oracle:
                    for (int i = 0; i < paramsCount; ++i)
                    {
                        idbParams[i] = new OracleParameter();
                    }
                    break;
                default:
                    idbParams = null;
                    break;
            }
            return idbParams;
        }
    }
}

Utilities DBMAnager

DBManager


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.SqlClient;
namespace HRHO_Utilities
{
    public class DBManager : IDBManager, IDisposable
    {
        private IDbConnection idbConnection;
        private IDataReader idataReader;
        private IDbCommand idbCommand;
        private DataProvider providerType;
        private IDbTransaction idbTransaction = null;
        private IDbDataParameter[] idbParameters = null;
        private string strConnection;

        /// <summary>
        /// Default Constructor
        /// </summary>
        public DBManager() { }

        /// <summary>
        /// Overloaded Constructor (First overload)
        /// </summary>
        /// <param name="providerType">Data provider type</param>
        public DBManager(DataProvider providerType)
        {
            this.providerType = providerType;
        }

        /// <summary>
        /// Overloaded Constructor (Second overload)
        /// </summary>
        /// <param name="providerType">Data provider type</param>
        /// <param name="connectionString">Connection string</param>
        public DBManager(DataProvider providerType, string connectionString)
        {
            this.providerType = providerType;
            this.strConnection = connectionString;
        }

        public IDbConnection Connection
        {
            get
            {
                return idbConnection;
            }
        }

        public IDataReader DataReader
        {
            get
            {
                return idataReader;
            }
            set
            {
                idataReader = value;
            }
        }

        public DataProvider ProviderType
        {
            get
            {
                return providerType;
            }
            set
            {
                providerType = value;
            }
        }

        public string ConnectionString
        {
            get
            {
                return strConnection;
            }
            set
            {
                strConnection = value;
            }
        }

        public IDbCommand Command
        {
            get
            {
                return idbCommand;
            }
        }

        public IDbTransaction Transaction
        {
            get
            {
                return idbTransaction;
            }
        }

        public IDbDataParameter[] Parameters
        {
            get
            {
                return idbParameters;
            }
        }

        public void Open()
        {
            idbConnection = DBManagerFactory.GetConnection(this.providerType);
            idbConnection.ConnectionString = this.ConnectionString;
            if (idbConnection.State != ConnectionState.Open)
                idbConnection.Open();
            this.idbCommand = DBManagerFactory.GetCommand(this.ProviderType);
        }

        public void Close()
        {
            if (idbConnection.State != ConnectionState.Closed)
                idbConnection.Close();
        }

        public void Dispose()
        {
            this.Close();
            this.idbCommand = null;
            this.idbTransaction = null;
            this.idbConnection = null;
            GC.SuppressFinalize(this);
        }

        public void CreateParameters(int paramsCount)
        {
            idbParameters = new IDbDataParameter[paramsCount];
            idbParameters = DBManagerFactory.GetParameters(this.ProviderType, paramsCount);
        }

        public void AddParameters(int index, string paramName, object objValue)
        {
            if (index < idbParameters.Length)
            {
                idbParameters[index].ParameterName = paramName;
                idbParameters[index].Value = objValue;
            }
        }

        public void AddParameters(int index, string paramName, object objValue, ParameterDirection direction)
        {
            if (index < idbParameters.Length)
            {
                idbParameters[index].ParameterName = paramName;
                idbParameters[index].Value = objValue;
                idbParameters[index].Direction = direction;
            }
        }

        public void AddParameters(int index, string paramName, object objValue, DbType type, int size, ParameterDirection direction)
        {
            if (index < idbParameters.Length)
            {
                idbParameters[index].ParameterName = paramName;
                idbParameters[index].Value = objValue;
                idbParameters[index].DbType = type;
                idbParameters[index].Size = size;
                idbParameters[index].Direction = direction;
            }
        }

        public void BeginTransaction()
        {
            if (this.idbTransaction == null)
                idbTransaction = DBManagerFactory.GetTransaction(this.ProviderType);
            this.idbCommand.Transaction = idbTransaction;
        }

        public void CommitTransaction()
        {
            if (this.idbTransaction != null)
                this.idbTransaction.Commit();
            idbTransaction = null;
        }

        public IDataReader ExecuteReader(CommandType commandType, string commandText)
        {
            this.idbCommand = DBManagerFactory.GetCommand(this.ProviderType);
            PrepareCommand(idbCommand, this.Connection, this.Transaction, commandType, commandText, this.Parameters);
            this.DataReader = idbCommand.ExecuteReader();
            idbCommand.Parameters.Clear();
            return this.DataReader;
        }

        public void CloseReader()
        {
            if (this.DataReader != null)
                this.DataReader.Close();
        }

        private void AttachParameters(IDbCommand command, IDbDataParameter[] commandParameters)
        {
            foreach (IDbDataParameter idbParameter in commandParameters)
            {
                if ((idbParameter.Direction == ParameterDirection.InputOutput) && (idbParameter.Value == null))
                {
                    idbParameter.Value = DBNull.Value;
                }
                command.Parameters.Add(idbParameter);
            }
        }

        private void PrepareCommand(IDbCommand command, IDbConnection connection, IDbTransaction transaction, CommandType commandType, string commandText, IDbDataParameter[] commandParameters)
        {
            command.Connection = connection;
            command.CommandText = commandText;
            command.CommandType = commandType;

            if (transaction != null)
            {
                command.Transaction = transaction;
            }

            if (commandParameters != null)
            {
                AttachParameters(command, commandParameters);
            }
        }

        public int ExecuteNonQuery(CommandType commandType, string commandText)
        {
            this.idbCommand = DBManagerFactory.GetCommand(this.ProviderType);
            PrepareCommand(idbCommand, this.Connection, this.Transaction,
            commandType, commandText, this.Parameters);
            int returnValue = idbCommand.ExecuteNonQuery();
            idbCommand.Parameters.Clear();
            return returnValue;
        }

        public object ExecuteScalar(CommandType commandType, string commandText)
        {
            this.idbCommand = DBManagerFactory.GetCommand(this.ProviderType);
            PrepareCommand(idbCommand, this.Connection, this.Transaction, commandType, commandText, this.Parameters);
            object returnValue = idbCommand.ExecuteScalar();
            idbCommand.Parameters.Clear();
            return returnValue;
        }

        public DataSet ExecuteDataSet(CommandType commandType, string commandText)
        {
            this.idbCommand = DBManagerFactory.GetCommand(this.ProviderType);
            PrepareCommand(idbCommand, this.Connection, this.Transaction, commandType, commandText, this.Parameters);
            IDbDataAdapter dataAdapter = DBManagerFactory.GetDataAdapter(this.ProviderType);
            dataAdapter.SelectCommand = idbCommand;
            DataSet dataSet = new DataSet();
            dataAdapter.Fill(dataSet);
            idbCommand.Parameters.Clear();
            return dataSet;
        }
        public void SQLBulkInsert(DataTable dt, string tableName)
        {
            SqlBulkCopy sqlBulkInsert = new SqlBulkCopy(strConnection);
            sqlBulkInsert.DestinationTableName = tableName;
            sqlBulkInsert.WriteToServer(dt);

        }
    }
}

ഒരു രാവിന്‍ നിലവില്....

ഒരു മഴത്തുള്ളിയില്‍ -ഈ ജന്മമ്......

മഴത്തുള്ളികള്‍ വീണ്ടുമിന്നീ ഭൂവില്‍ മുത്തമിടുമ്പോല്
മനസില്‍ ഞാന്‍ ഒളിപ്പിചു വച്ഛൊരാ തുളസിയും കതിരിടുന്നു।
ഒരുപാടു സന്ധ്യകളില്‍ നിറം പകര്‍ന്നൊരാ സ്വപ്നങ്ങള്
ഞനെന്‍ ഹ്രദയത്തില്‍ താരാട്ടു പാടിയുറക്കിയിരുന്നു।
അന്നേതോ പുലരിയില്‍ അവളെന്‍ നെഞ്ചില്‍ കുറിച്ചൊരാ വരികള്
ആരാരും കാണാതെ ഞനൊളിച്ചു വച്ചു॥
നിന്‍ മിഴികളെ പുണരുവാന്‍ ഞനെന്നുമാ അമ്പല
നടകളില്‍ കാത്തിരിന്നു।
എങ്കിലുമ്...
ആരൊ വിധിച്ച വിധിയുടെ കനല്പൂക്കള്‍
നിന്നില്‍ പതിചതാരുടെ തെറ്റ്‌?
ഈ നന്ദനോദ്യാനത്തില്‍നിന്നു നീ
യാത്രാ പറഞ്ഞെങ്ങു മറഞ്ഞു?
വീണ്ടുമൊരു വസന്തത്തിനായി... എന്
ഹ്രദയവും കാത്തിരിക്കുന്നു.......