連接任何數據庫

using System;
using System.Data;
using System.Data.Common;
using System.Data.OleDb;
using System.Data.SqlClient;

namespace DBSpaceName
{

    /**//// <summary>
    ///數據庫操作
    /// </summary>
    public class ExecuteDB : Connection
    {

        private System.Data.IDbCommand _command;
        private System.Data.IDataAdapter _dataAdaper;

        public ExecuteDB(){}

        Execute Sql#region Execute Sql

        /**//// <summary>
        /// Execute the Sql 
        /// </summary>
        /// <param name="sqlString">String for Sql</param>
        /// <returns>Succeed</returns>
        public static bool ExecuteSql(string sqlString)
        {
            try
            {
                IDbConnection Conn = DataFactory.CreateConnection(Connection.ConnectionString,Connection.DBType);
                IDbCommand command = DataFactory.CreateCommand(Connection.DBType,Conn);
                Conn.Open();
                command.CommandText = sqlString;
                command.ExecuteNonQuery();
                command.Dispose();
                Conn.Close();
                Conn.Dispose();
                return true;
            }
            catch(Exception exc)
            {
                Connection.ErrorInfo =exc.ToString();
                return false;
            }
        }

        /**//// <summary>
        /// Execute the Sql
        /// </summary>
        /// <param name="sqlString">String for Sql</param>
        /// <returns>IDataReader</returns>
        public static IDataReader ExecuteSqlDataReader(string sqlString)
        {
            IDbConnection Conn = DataFactory.CreateConnection(Connection.ConnectionString,Connection.DBType);
            IDbCommand command = DataFactory.CreateCommand(Connection.DBType,Conn);
            Conn.Open();
            IDataReader  dataReader;
            command.CommandText = sqlString;
            dataReader = command.ExecuteReader(CommandBehavior.CloseConnection);
            return dataReader;
        }

        /**//// <summary>
        /// Execute the Sql
        /// </summary>
        /// <param name="sqlString">String for Sql</param>
        /// <returns>DataSet</returns>
        public static DataSet ExcuteSqlDataSet(string sqlString)
        {
            DataSet ds = new DataSet();
            IDbConnection Conn = DataFactory.CreateConnection(Connection.ConnectionString,Connection.DBType);
            IDbCommand command = DataFactory.CreateCommand(Connection.DBType,Conn);
            Conn.Open();
            command.CommandText = sqlString;
            DbDataAdapter dataAdaper = DataFactory.CreateAdapter(command,Connection.DBType);
            dataAdaper.Fill(ds);
            command.Dispose();
            Conn.Close();
            Conn.Dispose();
            return ds;
        }

        #endregion

        Execute Procedure#region Execute Procedure 

        /**//// <summary>
        /// Excecute Procedure for not return value
        /// </summary>
        /// <param name="proName">the name of the procedure</param>
        public static void ExecutePro_void(string proName)
        {
            IDbConnection Conn = DataFactory.CreateConnection(Connection.ConnectionString,Connection.DBType);
            IDbCommand command = DataFactory.CreateCommand(Connection.DBType,Conn);
            Conn.Open();
            command.CommandText = proName;
            command.CommandType = CommandType.StoredProcedure;
            command.ExecuteNonQuery();
            command.Dispose();
            Conn.Close();
            Conn.Dispose();
        }

        /**//// <summary>
        /// Excecute Procedure for not return value
        /// </summary>
        /// <param name="proName">the name of the Procudure</param>
        /// <param name="parameterName">the name for the Parameter</param>
        /// <param name="parameterValue"></param>
        public static void ExecutePro_void(string proName,string parameterName,string parameterValue)
        {
            IDbConnection Conn = DataFactory.CreateConnection(Connection.ConnectionString,Connection.DBType);
            IDbCommand command = DataFactory.CreateCommand(Connection.DBType,Conn);
            Conn.Open();
            command.CommandText = proName;
            command.CommandType = CommandType.StoredProcedure;
            IDataParameter parameter = DataFactory.CreateParameter(parameterName,parameterValue,ParameterDirection.Input,Connection.DBType);
            command = DataFactory.CreateCommand(command,parameter);
            command.ExecuteNonQuery();
            command.Dispose();
            Conn.Close();
            Conn.Dispose();
        }

        /**//// <summary>
        /// Excecute Procedure for not return value
        /// </summary>
        /// <param name="proName">the name of the Procudure</param>
        /// <param name="parameterName">the names for the Parameter</param>
        /// <param name="parameterValue">the values for the Parameter</param>
        public static void ExecutePro_void(string proName,string[] parameterName,object[] parameterValue)
        {
            IDbConnection Conn = DataFactory.CreateConnection(Connection.ConnectionString,Connection.DBType);
            IDbCommand command = DataFactory.CreateCommand(Connection.DBType,Conn);
            Conn.Open();
            command.CommandText = proName;
            command.CommandType = CommandType.StoredProcedure;
            IDataParameter[] parameter = new IDataParameter[parameterName.Length];
            for(int i=0; i<parameterName.Length; i++)
            {
                parameter[i] = DataFactory.CreateParameter(parameterName[i],parameterValue[i],ParameterDirection.Input,Connection.DBType);
            }
            command = DataFactory.CreateCommand(command,parameter);
            command.ExecuteNonQuery();
            command.Dispose();
            Conn.Close();
            Conn.Dispose();
        }

        /**//// <summary>
        /// Excecute Procedure
        /// </summary>
        /// <param name="proName">the name of the procedure</param>
        /// <returns>object</returns>
        public static object ExecutePro_object(string proName)
        {
            object returnValue = null;
            IDbConnection Conn = DataFactory.CreateConnection(Connection.ConnectionString,Connection.DBType);
            IDbCommand command = DataFactory.CreateCommand(Connection.DBType,Conn);
            Conn.Open();
            command.CommandText = proName;
            command.CommandType = CommandType.StoredProcedure;
            IDataReader rs = command.ExecuteReader();
            if(rs.Read()) returnValue = rs[0].ToString();
            rs.Close();
            rs.Dispose();
            command.Dispose();
            Conn.Close();
            Conn.Dispose();
            return returnValue;
        }

        /**//// <summary>
        /// Excecute Procedure
        /// </summary>
        /// <param name="proName">the name of the Procedure</param>
        /// <param name="parameterName">the name for parameter</param>
        /// <param name="parameterValue">the value for parameter</param>
        /// <returns>object</returns>
        public static object ExecutePro_object(string proName,string parameterName,object parameterValue)
        {
            object returnValue = null;
            IDbConnection Conn = DataFactory.CreateConnection(Connection.ConnectionString,Connection.DBType);
            IDbCommand command = DataFactory.CreateCommand(Connection.DBType,Conn);
            Conn.Open();
            command.CommandText = proName;
            command.CommandType = CommandType.StoredProcedure;
            IDataParameter parameter = DataFactory.CreateParameter(parameterName,parameterValue,ParameterDirection.Input,Connection.DBType);
            command = DataFactory.CreateCommand(command,parameter);
            IDataReader rs = command.ExecuteReader();
            if(rs.Read()) returnValue = rs[0].ToString();
            rs.Close();
            rs.Dispose();
            command.Dispose();
            Conn.Close();
            Conn.Dispose();
            return returnValue;
        }

        /**//// <summary>
        /// Excecute Procedure
        /// </summary>
        /// <param name="proName">the name of the Procedure</param>
        /// <param name="parameterName">the names for parameter</param>
        /// <param name="parameterValue">the values for parameter</param>
        /// <returns>object</returns>
        public static object ExecutePro_object(string proName,string[] parameterName,object[] parameterValue)
        {
            object returnValue = null;
            IDbConnection Conn = DataFactory.CreateConnection(Connection.ConnectionString,Connection.DBType);
            IDbCommand command = DataFactory.CreateCommand(Connection.DBType,Conn);
            Conn.Open();
            command.CommandText = proName;
            command.CommandType = CommandType.StoredProcedure;
            IDataParameter[] myparam = new IDataParameter[parameterName.Length];
            for(int i=0; i<parameterName.Length; i++)
            {
                myparam[i] = DataFactory.CreateParameter(parameterName[i],parameterValue[i],ParameterDirection.Input,DBType);
            }
            command = DataFactory.CreateCommand(command,myparam);
            IDataReader rs = command.ExecuteReader();
            if(rs.Read()) returnValue = rs[0].ToString();
            rs.Close();
            rs.Dispose();
            command.Dispose();
            Conn.Close();
            Conn.Dispose();
            return returnValue;
        }

        /**//// <summary>
        /// Excecute Procedure
        /// </summary>
        /// <param name="proName">the name of the procedure</param>
        /// <returns>IDataReader</returns>
        public static IDataReader ExecutePro_DataReader(string proName)
        {
            IDbConnection Conn = DataFactory.CreateConnection(Connection.ConnectionString,Connection.DBType);
            IDbCommand command = DataFactory.CreateCommand(Connection.DBType,Conn);
            Conn.Open();
            command.CommandText = proName;
            command.CommandType = CommandType.StoredProcedure;
            return command.ExecuteReader(CommandBehavior.CloseConnection);
        }

        /**//// <summary>
        /// Excecute Procedure
        /// </summary>
        /// <param name="proName">the name of the procedure</param>
        /// <param name="parameterName">the name for parameter</param>
        /// <param name="parameterValue">the value for parameter</param>
        /// <returns>IDataReader</returns>
        public static IDataReader ExecutePro_DataReader(string proName, string parameterName, string parameterValue)
        {
            IDbConnection Conn = DataFactory.CreateConnection(Connection.ConnectionString,Connection.DBType);
            IDbCommand command = DataFactory.CreateCommand(Connection.DBType,Conn);
            Conn.Open();
            command.CommandText = proName;
            command.CommandType = CommandType.StoredProcedure;
            IDataParameter parameter = DataFactory.CreateParameter(parameterName,parameterValue,ParameterDirection.Input,Connection.DBType);
            command = DataFactory.CreateCommand(command,parameter);
            return command.ExecuteReader(CommandBehavior.CloseConnection);
        }

        /**//// <summary>
        /// Excecute Procedure
        /// </summary>
        /// <param name="proName">the name of the procedure</param>
        /// <param name="parameterName">the names for parameter</param>
        /// <param name="parameterValue">the values for parameter</param>
        /// <returns>IDataReader</returns>
        public static IDataReader ExecutePro_DataReader(string proName, string[] parameterName, string[] parameterValue)
        {
            IDbConnection Conn = DataFactory.CreateConnection(Connection.ConnectionString,Connection.DBType);
            IDbCommand command = DataFactory.CreateCommand(Connection.DBType,Conn);
            Conn.Open();
            command.CommandText = proName;
            command.CommandType = CommandType.StoredProcedure;
            IDataParameter[] parameter = new IDataParameter[parameterName.Length];
            for(int i=0; i<parameterName.Length; i++)
            {
                parameter[i] = DataFactory.CreateParameter(parameterName[i],parameterValue[i],ParameterDirection.Input,Connection.DBType);
            }
            command = DataFactory.CreateCommand(command,parameter);
            return command.ExecuteReader(CommandBehavior.CloseConnection);
        }

        /**//// <summary>
        /// Execute Procedure
        /// </summary>
        /// <param name="proName">the name for procedure</param>
        /// <returns>DataSet</returns>
        public static DataSet ExecutePro_DataSet(string proName)
        {
            DataSet ds = new DataSet();
            IDbConnection Conn = DataFactory.CreateConnection(Connection.ConnectionString,Connection.DBType);
            IDbCommand command = DataFactory.CreateCommand(Connection.DBType,Conn);
            command.CommandText = proName;
            command.CommandType = CommandType.StoredProcedure;
            DbDataAdapter dataAdaper = DataFactory.CreateAdapter(command,Connection.DBType);
            dataAdaper.Fill(ds);
            command.Dispose();
            Conn.Close();
            Conn.Dispose();
            return ds;
        }

        /**//// <summary>
        /// Execute Procedure
        /// </summary>
        /// <param name="proName">the name for procedure</param>
        /// <param name="parameterName">the name of the parameter</param>
        /// <param name="parameterValue">the value of the parameter</param>
        /// <returns>DataSet</returns>
        public static DataSet ExecutePro_DataSet(string proName, string parameterName, object parameterValue)
        {
            DataSet ds = new DataSet();
            IDbConnection Conn = DataFactory.CreateConnection(Connection.ConnectionString,Connection.DBType);
            IDbCommand command = DataFactory.CreateCommand(Connection.DBType,Conn);
            command.CommandText = proName;
            command.CommandType = CommandType.StoredProcedure;
            IDataParameter parameter = DataFactory.CreateParameter(parameterName,parameterValue,ParameterDirection.Input,Connection.DBType);
            command = DataFactory.CreateCommand(command,parameter);
            DbDataAdapter dataAdaper = DataFactory.CreateAdapter(command,Connection.DBType);
            dataAdaper.Fill(ds);
            command.Dispose();
            Conn.Close();
            Conn.Dispose();
            return ds;
        }

        /**//// <summary>
        /// Execute Procedure
        /// </summary>
        /// <param name="proName">the name for procedure</param>
        /// <param name="parameterName">the name of the parameter</param>
        /// <param name="parameterValue">the value of the parameter</param>
        /// <returns>DataSet</returns>
        public static DataSet ExecutePro_DataSet(string proName,string[] parameterName,object[] parameterValue)
        {
            DataSet ds = new DataSet();
            IDbConnection Conn = DataFactory.CreateConnection(Connection.ConnectionString,Connection.DBType);
            IDbCommand command = DataFactory.CreateCommand(Connection.DBType,Conn);
            command.CommandText = proName;
            command.CommandType = CommandType.StoredProcedure;
            IDataParameter[] myparam = new IDataParameter[parameterName.Length];
            for(int i=0; i<parameterName.Length; i++)
            {
                myparam[i] = DataFactory.CreateParameter(parameterName[i],parameterValue[i],ParameterDirection.Input,DBType);
            }
            command = DataFactory.CreateCommand(command,myparam);
            DbDataAdapter dataAdaper = DataFactory.CreateAdapter(command,Connection.DBType);
            dataAdaper.Fill(ds);
            command.Dispose();
            Conn.Close();
            Conn.Dispose();
            return ds;
        }

        #endregion 

    }
}