公用SQLHelper類-數據訪問層文件

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Data.OracleClient;
using System.Data.OleDb;
using System.Data.Odbc;
using System.Reflection;

namespace WebDAL
{

    public class DBHelper
    {
        #region 屬性

        //項目中添加如下引用
        //System.Configuration
        //System.Data.OracleClient


        //web.config中增加如下節點
        //<appSettings>
        //<add key="DBType" value="SQLServer"/>配置數據庫類型SQLServer||OleDb||ODBC||Oracle
        //<add key="SQLServer" value="連庫字符串"/>配置該數據庫類型對應的連庫字符串
        //<add key="assemblyName" value="Entity"/>指定實體類的命名空間
        //</appSettings>

        //獲取連接字符串和數據庫類型
        //從Web.config文件中動態獲取
        
        private static string conType=ConfigurationManager.AppSettings["DBType"].ToString();

        private static string constr = ConfigurationManager.AppSettings[conType].ToString();

        //動態獲取程序集名稱，以備反射時所用
        private static string assemblyName = ConfigurationManager.AppSettings["assemblyName"].ToString();
        #endregion

        #region 私有方法

        /// <summary>
        /// 根據數據庫類型，獲取對應數據庫的連接
        /// </summary>
        /// <returns>連接接口</returns>
        private static IDbConnection GetConnection()
        {
            IDbConnection con = null;
            if (conType == DBType.SQLServer.ToString())
            {
                con = new SqlConnection(constr);
            }
            else if (conType == DBType.Oracle.ToString())
            {
                con = new OracleConnection(constr);
            }
            else if (conType == DBType.OleDb.ToString())
            {
                con = new OleDbConnection(constr);
            }
            else if (conType == DBType.ODBC.ToString())
            {
                con = new OdbcConnection(constr);
            }
            else
            {
                con = new SqlConnection(constr);
            }
            return con;
        }

        /// <summary>
        /// 根據數據庫類型，獲取對應Command對象
        /// </summary>
        /// <param name="cmdText">SQL語句或存儲過程名</param>
        /// <param name="cmdType">SQL命令類型</param>
        /// <param name="con">連接對象</param>
        /// <param name="param">SQL命令參數數組</param>
        /// <returns>Command接口對象</returns>
        private static IDbCommand GetCommand(string commandText,CommandType commandType,IDbConnection con, params IDbDataParameter[] param)
        {
            IDbCommand cmd = null;
            if (conType == DBType.SQLServer.ToString())
            {
                cmd = new SqlCommand(commandText,con as SqlConnection);
            }
            else if (conType == DBType.Oracle.ToString())
            {
                cmd = new OracleCommand(commandText, con as OracleConnection);
            }
            else if (conType == DBType.OleDb.ToString())
            {
                cmd = new OleDbCommand(commandText,con as OleDbConnection);
            }
            else if (conType == DBType.ODBC.ToString())
            {
                cmd = new OdbcCommand(commandText,con as OdbcConnection);
            }
            else
            {
                cmd = new SqlCommand(commandText, con as SqlConnection);
            }
            cmd.CommandType = commandType;
            if (param != null)
            {
                cmd.Parameters.Add(param);
            }
            return cmd;
        }

        /// <summary>
        /// 執行返回一條記錄的泛型集合對象
        /// </summary>
        /// <typeparam name="T">泛型類型</typeparam>
        /// <param name="reader">Reader對象，用於讀取數據結果集</param>
        /// <returns>泛型對象</returns>
        private static T ExexuteDataReader<T>(IDataReader reader)
        {
            T obj = default(T);
            try
            {
                Type type = typeof(T);
                obj = (T)Assembly.Load(DBHelper.assemblyName).CreateInstance(assemblyName + "." + type.Name);
                PropertyInfo[] propertyInfos = type.GetProperties();
                foreach (PropertyInfo propertyinfo in propertyInfos)
                {
                    for (int i = 0; i < reader.FieldCount; i++)
                    {
                        string filedName = reader.GetName(i);
                        if (filedName.ToLower() == propertyinfo.Name.ToLower())
                        {
                            Object value = reader[propertyinfo.Name];
                            if (value != null && value != DBNull.Value)
                            {
                                propertyinfo.SetValue(obj, value, null);
                                break;
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return obj;
        }
        #endregion

        


#region 公有方法
        /// <summary>
        /// 執行返回一行一列的數據庫操作
        /// </summary>
        /// <param name="cmdText">SQL語句或存儲過程名</param>
        /// <param name="cmdType">SQL命令類型</param>
        /// <param name="param">SQL命令參數數組</param>
        /// <returns>第一行第一列記錄</returns>
        public static int ExecuteScalar(string commandText, CommandType commandType, params IDbDataParameter[] param)
        {
            int result = 0;
            try
            {
                IDbConnection con = GetConnection();
                IDbCommand cmd = GetCommand(commandText, commandType, con, param);
                using (con)
                {
                    using (cmd)
                    {
                        con.Open();
                        result = Convert.ToInt32(cmd.ExecuteScalar());
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return result;
        }

        /// <summary>
        /// 執行非查詢的數據庫操作
        /// </summary>
        /// <param name="cmdText">SQL語句或存儲過程名</param>
        /// <param name="cmdType">SQL命令類型</param>
        /// <param name="param">SQL命令參數數組</param>
        /// <returns>受影響的行數</returns>
        public static int ExecuteNonQuery(string commandText, CommandType commandType, params IDbDataParameter[] param)
        {
            int result = 0;
            try
            {
                IDbConnection con = GetConnection();
                IDbCommand cmd = GetCommand(commandText, commandType, con, param);
                using (con)
                {
                    using (cmd)
                    {
                        con.Open();
                        IDbTransaction tr = con.BeginTransaction();
                        cmd.Transaction = tr;
                        try
                        {
                            result = Convert.ToInt32(cmd.ExecuteNonQuery());
                            tr.Commit();
                        }
                        catch (Exception ex)
                        {
                            tr.Rollback();
                            throw ex;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return result;
        }

        /// <summary>
        /// 執行返回一條記錄的泛型對象
        /// </summary>
        /// <typeparam name="T">泛型類型</typeparam>
        /// <param name="commandText">SQL語句或存儲過程名</param>
        /// <param name="commandType">SQL命令類型</param>
        /// <param name="param">SQL命令參數數組</param>
        /// <returns>實體對象</returns>
        public static T ExexuteEntity<T>(string commandText, CommandType commandType, params IDbDataParameter[] param)
        { 
            T obj = default(T);
            try
            {
                IDbConnection con = GetConnection();
                IDbCommand cmd = GetCommand(commandText, commandType, con, param);
                using (con)
                {
                    using (cmd)
                    {
                        con.Open();
                        IDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                        while (reader.Read())
                        {
                            obj = DBHelper.ExexuteDataReader<T>(reader);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return obj;
        }

        /// <summary>
        /// 執行返回多行記錄的泛型集合對象
        /// </summary>
        /// <typeparam name="T">泛型類型</typeparam>
        /// <param name="commandText">SQL語句或村存儲過程名</param>
        /// <param name="commandType">SQL命令類型</param>
        /// <param name="param">SQL命令參數數組</param>
        /// <returns>泛型集合對象</returns>
        public static List<T> ExecuteList<T>(string commandText, CommandType commandType, params IDbDataParameter[] param)
        {
            List<T> list = new List<T>();
            try
            {
                IDbConnection con = GetConnection();
                IDbCommand cmd = GetCommand(commandText, commandType, con, param);
                using (con)
                {
                    using (cmd)
                    {
                        con.Open();
                        IDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                        while (reader.Read())
                        {
                            T obj = DBHelper.ExexuteDataReader<T>(reader);
                            list.Add(obj);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return list;
        }
        #endregion
    }

    #region 數據庫類型枚舉
    /// <summary>
    /// 該枚舉類型用於創建合適的數據庫訪問對象
    /// </summary>
    public enum DBType
    {
        SQLServer,
        OleDb,
        ODBC,
        Oracle
    }
    #endregion
}