OracleHelper類


using System;
using System.Configuration;
using System.Data;
using System.Collections;
using Oracle.DataAccess.Client;

namespace OracleHelper
{

    /// <summary>
    ///Oracle數據庫操作幫助類
    /// </summary>
    public abstract class OracleHelper
    {

        //從配置文件中讀取配置好的連接字符串
        public static readonly string ConnectionStringLocalTransaction = ConfigurationManager.ConnectionStrings["OraConnString1"].ConnectionString;
        public static readonly string ConnectionStringInventoryDistributedTransaction = ConfigurationManager.ConnectionStrings["OraConnString2"].ConnectionString;
        public static readonly string ConnectionStringOrderDistributedTransaction = ConfigurationManager.ConnectionStrings["OraConnString3"].ConnectionString;
        public static readonly string ConnectionStringProfile = ConfigurationManager.ConnectionStrings["OraProfileConnString"].ConnectionString;
        public static readonly string ConnectionStringMembership = ConfigurationManager.ConnectionStrings["OraMembershipConnString"].ConnectionString;

        //為緩存的參數創建一個hashtable
        private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable());

        /// <summary>
        /// 增刪改操作使用此方法
        /// </summary>
        /// <param name="connString">連接字符串</param>
        /// <param name="cmdType">命令類型(sql語句或者存儲過程)</param>
        /// <param name="cmdText">要執行的sql語句或者存儲過程名稱</param>
        /// <param name="commandParameters">執行所需的一些參數</param>
        /// <returns>返回受影響的行數</returns>
        public static int ExecuteNonQuery(string connectionString, CommandType cmdType, string cmdText, params OracleParameter[] commandParameters)
        {
            // 創建一個OracleCommand
            OracleCommand cmd = new OracleCommand();
            //創建一個OracleConnection
            using (OracleConnection connection = new OracleConnection(connectionString))
            {
                //調用靜態方法PrepareCommand完成賦值操作
                PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
                //執行命令返回
                int val = cmd.ExecuteNonQuery();
                //清空參數
                cmd.Parameters.Clear();
                return val;
            }
        }

        /// <summary>
        /// 增刪改操作使用此方法(需要一個存在的事務參數)
        /// </summary>
        /// <param name="trans">一個存在的事務</param>
        /// <param name="commandType">命令類型(sql或者存儲過程)</param>
        /// <param name="commandText">sql語句或者存儲過程名稱</param>
        /// <param name="commandParameters">命令所需參數數組</param>
        /// <returns>返回受影響的行數</returns>
        public static int ExecuteNonQuery(OracleTransaction trans, CommandType cmdType, string cmdText, params OracleParameter[] commandParameters)
        {
            // 創建一個OracleCommand
            OracleCommand cmd = new OracleCommand();
            //調用靜態方法PrepareCommand完成賦值操作
            PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, commandParameters);
            //執行命令返回
            int val = cmd.ExecuteNonQuery();
            //清空參數
            cmd.Parameters.Clear();
            return val;
        }

        /// <summary>
        /// 增刪改操作使用此方法(需要一個存在的連接)
        /// </summary> 
        /// <param name="conn">一個存在的OracleConnection參數</param>
        /// <param name="commandType">命令類型(sql或者存儲過程)</param>
        /// <param name="commandText">sql語句或者存儲過程名稱</param>
        /// <param name="commandParameters">命令所需參數數組</param>
        /// <returns>返回受影響的行數</returns>
        public static int ExecuteNonQuery(OracleConnection connection, CommandType cmdType, string cmdText, params OracleParameter[] commandParameters)
        {
            // 創建一個OracleCommand
            OracleCommand cmd = new OracleCommand();
            //調用靜態方法PrepareCommand完成賦值操作
            PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
            //執行命令返回
            int val = cmd.ExecuteNonQuery();
            //清空參數
            cmd.Parameters.Clear();
            return val;
        }

        /// <summary>
        /// 查詢返回一個結果集
        /// </summary>
        /// <param name="connString">連接字符串</param>
        //// <param name="commandType">命令類型(sql或者存儲過程)</param>
        /// <param name="commandText">sql語句或者存儲過程名稱</param>
        /// <param name="commandParameters">命令所需參數數組</param>
        /// <returns></returns>
        public static OracleDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText, params OracleParameter[] commandParameters)
        {

            // 創建一個OracleCommand
            OracleCommand cmd = new OracleCommand();
            // 創建一個OracleConnection
            OracleConnection conn = new OracleConnection(connectionString);
            try
            {
                //調用靜態方法PrepareCommand完成賦值操作
                PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                //執行查詢
                OracleDataReader odr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                //清空參數
                cmd.Parameters.Clear();
                return odr;

            }
            catch
            {
                //如果發生異常,關閉連接,並且向上拋出異常
                conn.Close();
                throw;
            }
        }

        /// <summary>
        /// 執行語句返回的是單行單列的結果 
        /// </summary>
        /// <param name="connectionString">連接字符串</param>
        /// <param name="commandType">命令類型(sql或者存儲過程)</param>
        /// <param name="commandText">sql語句或者存儲過程名稱</param>
        /// <param name="commandParameters">命令所需參數數組</param>
        /// <returns>返回是第一行第一列的結果(object類型)請使用Covert.to進行類型轉換</returns>
        public static object ExecuteScalar(string connectionString, CommandType cmdType, string cmdText, params OracleParameter[] commandParameters)
        {
            // 創建一個OracleCommand
            OracleCommand cmd = new OracleCommand();
            // 創建一個OracleConnection
            using (OracleConnection conn = new OracleConnection(connectionString))
            {
                //調用靜態方法PrepareCommand完成賦值操作
                PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                //執行查詢
                object val = cmd.ExecuteScalar();
                //清空參數
                cmd.Parameters.Clear();
                return val;
            }
        }

        ///    <summary>
        ///    執行語句返回的是單行單列的結果(有指定的事務參數)
        ///    </summary>
        ///    <param name="transaction">一個存在的事務參數</param>
        ///    <param name="commandType">命令類型(sql或者存儲過程)</param>
        ///    <param name="commandText">sql語句或者存儲過程名稱</param>
        ///    <param name="commandParameters">命令所需參數數組</param>
        ///    <returns>返回是第一行第一列的結果(object類型)請使用Covert.to進行類型轉換</returns>
        public static object ExecuteScalar(OracleTransaction transaction, CommandType commandType, string commandText, params OracleParameter[] commandParameters)
        {
            //如果傳入的事務是空值,拋出異常
            if (transaction == null)
                throw new ArgumentNullException("transaction");
            //如果傳入的事務無連接,拋出異常(無連接,說明傳入的事務參數是已經提交過或者回滾了的事務)
            if (transaction != null && transaction.Connection == null)
                throw new ArgumentException("The transaction was rollbacked    or commited, please    provide    an open    transaction.", "transaction");
            // 創建一個OracleCommand
            OracleCommand cmd = new OracleCommand();
            //調用靜態方法PrepareCommand完成賦值操作
            PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters);
            //執行查詢
            object retval = cmd.ExecuteScalar();
            //清空參數
            cmd.Parameters.Clear();
            return retval;
        }

        /// <summary>
        ///   執行語句返回的是單行單列的結果(有指定的連接參數)
        /// </summary>
        /// <param name="conn">一個存在的連接參數</param>
        /// <param name="commandType">命令類型(sql或者存儲過程)</param>
        /// <param name="commandText">sql語句或者存儲過程名稱</param>
        /// <param name="commandParameters">命令所需參數數組</param>
        /// <returns>返回是第一行第一列的結果(object類型)請使用Covert.to進行類型轉換</returns>
        public static object ExecuteScalar(OracleConnection connectionString, CommandType cmdType, string cmdText, params OracleParameter[] commandParameters)
        {
            // 創建一個OracleCommand
            OracleCommand cmd = new OracleCommand();
            //調用靜態方法PrepareCommand完成賦值操作
            PrepareCommand(cmd, connectionString, null, cmdType, cmdText, commandParameters);
            //執行查詢
            object val = cmd.ExecuteScalar();
            //清空參數
            cmd.Parameters.Clear();
            return val;
        }

        /// <summary>
        /// Add a set of parameters to the cached
        /// </summary>
        /// <param name="cacheKey">Key value to look up the parameters</param>
        /// <param name="commandParameters">Actual parameters to cached</param>
        public static void CacheParameters(string cacheKey, params OracleParameter[] commandParameters)
        {
            parmCache[cacheKey] = commandParameters;
        }

        /// <summary>
        /// 從緩存中獲取參數
        /// </summary>
        /// <param name="cacheKey">look up 中的cachekey</param>
        /// <returns></returns>
        public static OracleParameter[] GetCachedParameters(string cacheKey)
        {
            OracleParameter[] cachedParms = (OracleParameter[])parmCache[cacheKey];

            if (cachedParms == null)
                return null;

            // 如果緩存中有此參數
            OracleParameter[] clonedParms = new OracleParameter[cachedParms.Length];

            // 返回參數的copy
            for (int i = 0, j = cachedParms.Length; i < j; i++)
                clonedParms[i] = (OracleParameter)((ICloneable)cachedParms[i]).Clone();

            return clonedParms;
        }

        /// <summary>
        /// 一個靜態的預處理函數
        /// </summary>
        /// <param name="cmd">存在的OracleCommand對象</param>
        /// <param name="conn">存在的OracleConnection對象</param>
        /// <param name="trans">存在的OracleTransaction對象</param>
        /// <param name="cmdType">命令類型(sql或者存在過程)</param>
        /// <param name="cmdText">sql語句或者存儲過程名稱</param>
        /// <param name="commandParameters">Parameters for the command</param>
        private static void PrepareCommand(OracleCommand cmd, OracleConnection conn, OracleTransaction trans, CommandType cmdType, string cmdText, OracleParameter[] commandParameters)
        {

            //如果連接未打開,先打開連接
            if (conn.State != ConnectionState.Open)
                conn.Open();

            //未要執行的命令設置參數
            cmd.Connection = conn;
            cmd.CommandText = cmdText;
            cmd.CommandType = cmdType;

            //如果傳入了事務,需要將命令綁定到指定的事務上去
            if (trans != null)
                cmd.Transaction = trans;

            //將傳入的參數信息賦值給命令參數
            if (commandParameters != null)
            {
                cmd.Parameters.AddRange(commandParameters);
            }
        }
    }
}

 


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM