עמוד ראשי  |  התחבר או אם אינך עדיין רשום, הרשם בחינם.
  בלוגר  
אודות
קבלת עדכונים
רוצים לקבל הודעה במייל בכל פעם שהבלוג שלי מתעדכן ?

עדכוני RSS
חיפוש
ארכיון
SQL - database Access
24/11/2011 15:57
qaqa
/////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
IDataBaseApi.cs
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Linq;
using System.Text;

namespace ConsoleApplication2
{
    public interface IDataBaseApi : IDisposable
    {
        //string ConnectionString { get; set; }
        DbConnection Connection { get; }
        bool IsConnected { get; }
        bool Connect(string conString);
        bool Reconnect();
        bool Disconnect();

        bool TableExist(string tableName);

        DataTable GetData(string sql);
        DataTable GetData(DbCommand command);
        void GetData(string sql, ref DataTable dt);
        void GetData(DbCommand command, ref DataTable dt);
        int ExecuteNonQuery(string sqlCommand, CommandType cmdType);
        int ExecuteNonQuery(DbCommand command);
        int ExecuteNonQuery(string sql, CommandType cmdType, DbParameter[] dbParams);
        object GetSingleValue(DbCommand command);
        object GetSingleValue(string sql, CommandType cmdType);
        object GetSingleValue(string sql, CommandType cmdType, DbParameter[] dbParams);
        DbCommand GenerateCommand(string sql, CommandType cmdType, DbParameter[] dbParams);

        DbParameter CreateParameter();
        DbCommand CreateCommand();

        bool IsTransactionActive { get; }
        DbTransaction CurrentTransaction { get; }
        DbTransaction BeginTransaction();
        DbTransaction BeginTransaction(IsolationLevel isolationLevel);
        void CommitTransaction();
        void RollbackTransaction();

        List<string> GetAllTableNames();
        List<string> GetColumnNames(string tableName);
    }
}












//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
GenericDb.cs
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////





using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;

namespace ConsoleApplication2
{
    public abstract class GenericDb<TConnection, TCommand, TParameter> : IDataBaseApi
        where TConnection : DbConnection, new()
        where TCommand : DbCommand, new()
        where TParameter : DbParameter, new() 
    {

        private TConnection _connection;

        protected void CreateConnection()
        {
            _connection = new TConnection();
        }

        public virtual DbConnection Connection
        {
            get { return _connection; }
        }

        public virtual DbParameter CreateParameter()
        {
            return new TParameter();
        }

        public virtual DbCommand CreateCommand()
        {
            var newCommand = new TCommand();
            newCommand.Connection = Connection;
            return newCommand;
        }

        public virtual bool IsConnected
        {
            get
            {
                bool ret = false;
                if (Connection != null)
                    ret = (Connection.State == ConnectionState.Open);
                return ret;
            }
        }

        public virtual bool Reconnect()
        {
            if (Connection != null && !String.IsNullOrEmpty(Connection.ConnectionString))
                return Connect(Connection.ConnectionString);
            return false;
        }

        public abstract bool Connect();

        public virtual bool Connect(string connectionString)
        {
            try
            {
                if (Connection != null)
                {
                    Disconnect();
                }
                else
                {
                    CreateConnection();
                }
                if (Connection == null)
                    throw new ApplicationException("Failed to create DB connection.");

                Connection.ConnectionString = connectionString;
                Connection.Open();
                return true;
            }
            catch (Exception ex)
            {
                // TODO: Handle Connetion Failure Here.
                throw;
            }
        }

        public virtual bool Disconnect()
        {
            if (Connection == null)
                return false;

            try
            {
                if (IsTransactionActive)
                    CurrentTransaction.Dispose();
            }
            catch { }
            finally
            {
                CurrentTransaction = null;
                IsTransactionActive = false;
            }

            if (Connection.State != ConnectionState.Closed)
            {
                try
                {
                    Connection.Close();
                }
                catch { }
                try
                {
                    Connection.Dispose();
                }
                catch { }
            }
            return true;
        }

        public virtual void Dispose()
        {
            Disconnect();
        }


        public virtual DataTable GetData(string sql)
        {
            DataTable dt = new DataTable();
            DbDataReader reader = GetReader(ref sql);
            dt.Load(reader);
            reader.Dispose();
            return dt;
        }

        public virtual DataTable GetData(DbCommand command)
        {
            DataTable dt = new DataTable();
            DbDataReader reader = command.ExecuteReader();
            dt.Load(reader);
            reader.Dispose();
            return dt;
        }

        public virtual void GetData(string sql, ref DataTable dt)
        {
            DbDataReader reader = GetReader(ref sql);
            dt.Load(reader);
            reader.Dispose();
        }

        public virtual void GetData(DbCommand command, ref DataTable dt)
        {
            DbDataReader reader = command.ExecuteReader();
            dt.Load(reader);
            reader.Dispose();
        }

        public virtual int ExecuteNonQuery(string sqlCommand, CommandType cmdType)
        {
            DbCommand cmd = GetCommand(ref sqlCommand, cmdType);
            return cmd.ExecuteNonQuery();
        }

        public virtual int ExecuteNonQuery(DbCommand command)
        {
            return command.ExecuteNonQuery();
        }

        public virtual int ExecuteNonQuery(string sql, CommandType cmdType, DbParameter[] dbParams)
        {
            DbCommand cmd = GenerateCommand(sql, cmdType, dbParams);
            return cmd.ExecuteNonQuery();
        }

        public virtual object GetSingleValue(DbCommand command)
        {
            return command.ExecuteScalar();
        }

        public virtual object GetSingleValue(string sql, CommandType cmdType)
        {
            DbCommand cmd = GetCommand(ref sql, cmdType);
            return cmd.ExecuteScalar();
        }

        public virtual object GetSingleValue(string sql, CommandType cmdType, DbParameter[] dbParams)
        {
            DbCommand cmd = this.GenerateCommand(sql, cmdType, dbParams);
            return cmd.ExecuteScalar();
        }

        public virtual DbCommand GenerateCommand(string sql, CommandType cmdType, DbParameter[] dbParams)
        {
            DbCommand cmd = GetCommand(ref sql, cmdType);
            cmd.Parameters.AddRange(dbParams);
            return cmd;
        }

        protected DbCommand GetCommand(ref string sqlCommand, CommandType cmdType)
        {
            if (Connection == null)
                throw new ApplicationException("Command cannot be created since connection is not initialized.");

            var ret = new TCommand
            {
                CommandType = cmdType,
                CommandText = sqlCommand,
                Connection = Connection,
                CommandTimeout = 0
            };

            if (IsTransactionActive)
            {
                if (CurrentTransaction != null)
                    ret.Transaction = CurrentTransaction;
                else
                    throw new ApplicationException("Cannot assign null transaction to command.");
            }

            return ret;
        }

        protected DbDataReader GetReader(ref string sql)
        {
            if (Connection == null) return null;

            var cmd = new TCommand
            {
                CommandType = CommandType.Text,
                CommandText = sql,
                Connection = Connection,
                CommandTimeout = 0
            };

            if (IsTransactionActive)
            {
                if (CurrentTransaction != null)
                    cmd.Transaction = CurrentTransaction;
                else
                    throw new ApplicationException("Cannot assign null transaction to command.");
            }

            return cmd.ExecuteReader();
        }

        #region Transaction Handling
        object transLock = new object();
        public DbTransaction CurrentTransaction { get; set; }
        public bool IsTransactionActive { get; set; }

        public virtual DbTransaction BeginTransaction()
        {
            return BeginTransaction(IsolationLevel.Unspecified, false);
        }
        public virtual DbTransaction BeginTransaction(IsolationLevel isolationLevel)
        {
            return BeginTransaction(isolationLevel, false);
        }
        public virtual void CommitTransaction()
        {
            TransCommitRollback(true);
        }
        public virtual void RollbackTransaction()
        {
            TransCommitRollback(false);
        }

        protected DbTransaction BeginTransaction(IsolationLevel il, bool useIL)
        {
            lock (transLock)
            {
                if (!IsConnected)
                    throw new ApplicationException("Transaction cannot begin when connection is not established.");

                if (IsTransactionActive)
                    throw new ApplicationException("A transaction is already being active.");

                CurrentTransaction = (useIL ? Connection.BeginTransaction(il) : Connection.BeginTransaction());
                IsTransactionActive = true;
            }

            return CurrentTransaction;
        }

        protected void TransCommitRollback(bool isCommit)
        {
            lock (transLock)
            {
                try
                {
                    if (CurrentTransaction != null)
                    {
                        if (isCommit)
                            CurrentTransaction.Commit();
                        else
                            CurrentTransaction.Rollback();

                        CurrentTransaction.Dispose();
                    }
                }
                finally
                {
                    IsTransactionActive = false;
                    CurrentTransaction = null;
                }
            }
        }
        #endregion

        #region API Samples

        public List<string> GetAllTableNames()
        {
            if (Connection == null)
                throw new ApplicationException("Command cannot be created since connection is not initialized.");

            List<string> tableNames = new List<string>(100);

            DataTable schemaTable = Connection.GetSchema("Tables", new[] { null, null, null, "TABLE" });

            foreach (DataRow row in schemaTable.Rows)
                tableNames.Add(row[2].ToString());

            return tableNames;
        }

        public List<string> GetColumnNames(string tableName)
        {
            if (Connection == null)
                throw new ApplicationException("Command cannot be created since connection is not initialized.");

            var columnNames = new Dictionary<long, string>(20);

            DataTable schemaTable = Connection.GetSchema("Columns", new[] { null, null, tableName, null });

            foreach (DataRow row in schemaTable.Rows)
            {
                var colName = row[3].ToString();
                var ordinal = (long)row[6];
                columnNames.Add(ordinal, colName);
            }

            var sortedColumns = new List<string>();
            for (int i = 1; i <= columnNames.Count; i++)
                sortedColumns.Add(columnNames[i]);

            return sortedColumns;
        }

        public bool TableExist(string tableName)
        {
            try
            {
                DbCommand cmd = CreateCommand();
                cmd.CommandText = string.Format("SELECT 1 FROM {0} WHERE 1=2", tableName);
                cmd.ExecuteNonQuery();
            }
            catch
            {
                return false;
            }
            return true;
        }
        #endregion
    }
}














//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
DataBaseClasses.cs
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////









using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Data.Odbc;
using System.Data.OleDb;
using System.Data.SqlClient;
using System.Linq;
using System.Text;

namespace ConsoleApplication2
{
    class SqlDataBaseClass : GenericDb<SqlConnection, SqlCommand, SqlParameter>
    {
        public override bool Connect()
        {
            // for connection string samples see:
            // http://www.connectionstrings.com/sql-server-2008
            var sqlServer = "myServerAddress";
            var dbName = "myDataBase";
            var userName = "myUsername";
            var password = "myPassword";

            var connectionString = string.Format("Data Source={0};Initial Catalog={1};User Id={2};Password={3};",
                sqlServer, dbName, userName, password);
            
            return base.Connect(connectionString);
        }
    }

    class OleDbDataBaseClass : GenericDb<OleDbConnection, OleDbCommand, OleDbParameter>
    {
        public override bool Connect()
        {
            // for connection string samples see:
            // http://www.connectionstrings.com/sql-server-2008
            var sqlServer = "myServerAddress";
            var dbName = "myDataBase";
            var userName = "myUsername";
            var password = "myPassword";

            var connectionString = string.Format("Data Source={0};Initial Catalog={1};User Id={2};Password={3};",
                sqlServer, dbName, userName, password);

            return base.Connect(connectionString);
        }
    }

    class OdbcDataBaseClass : GenericDb<OdbcConnection, OdbcCommand, OdbcParameter>
    {
        public override bool Connect()
        {
            // for connection string samples see:
            // http://www.connectionstrings.com/sql-server-2008
            var sqlServer = "myServerAddress";
            var dbName = "myDataBase";
            var userName = "myUsername";
            var password = "myPassword";

            var connectionString = string.Format("Data Source={0};Initial Catalog={1};User Id={2};Password={3};",
                sqlServer, dbName, userName, password);

            return base.Connect(connectionString);
        }
    }





    
}









///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Program.cs
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////






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

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                var db = new OleDbDataBaseClass(); // can be: SqlDataBaseClass, OdbcDataBaseClass diffrent providers same code !!!
                db.Connect();
                ReadTable(db, "myTableName");
                db.Disconnect();
            }
            catch(Exception ex)
            {
                // TODO:
            }
        }

        static void ReadTable(IDataBaseApi db, string tableName)
        {
            if(!db.TableExist(tableName))
                throw new ApplicationException(string.Format("Table does not exist. Table Name: {0}.", tableName));

            DbCommand cmd = db.CreateCommand();
            cmd.CommandText = "select * from " + tableName;
            cmd.CommandType = CommandType.Text;

            //http://msdn.microsoft.com/en-us/library/haa3afyz(VS.71).aspx
            // Note that while a DataReader is open, the Connection is in use exclusively by that DataReader.
            // You will not be able to execute any commands for the Connection, including creating another DataReader,
            // until the original DataReader is closed.
            DbDataReader reader = cmd.ExecuteReader();

            try
            {
                while (reader.Read())
                {
                    // Depend on your tabel content, read row data by columns
                    DateTime readTime = reader.GetDateTime(0);
                    Int16 readShort = reader.GetInt16(1);
                    int readInt = reader.GetInt32(2);
                    float readFloat = reader.GetFloat(3);
                    string readString = reader.GetString(4);
                    // End of Row. Continue to Next Row
                }
            }
            finally
            {
                reader.Close();
                reader.Dispose();
            }
        }
    }
}


0 תגובות