DbHelper and OracleHelper

1 连接Sql Server的ConnectionString:

Data Source=.;Initial Catalog=ViewVideo;User ID=sa;Password=XXXXXX;

2 连接MySql的ConnectionString:

Database=dbname;Data Source=192.168.1.1;Port=3306;User Id=root;Password=****;Charset=utf8;TreatTinyAsBoolean=false;

3 连接Oracle的ConnectionString：

Data Source=(DESCRIPTION =
(ADDRESS_LIST =
(ADDRESS = (PROTOCOL = TCP)(HOST = 192.168.1.117)(PORT = 1521))
)
(CONNECT_DATA =
(SERVER = DEDICATED)
(SERVICE_NAME = orcl.192.168.1.117)
)
);User Id=scott;Password=XXXXXX //不能有';'

OracleHelper.cs:

public class OracleHepler
    {
        //链接字符串
        private static readonly string connStr = ConfigurationManager.ConnectionStrings["dbconnStr"].ConnectionString;

        /// <summary>
        /// 创建链接
        /// </summary>
        /// <returns>链接</returns>
        public static OracleConnection CreateConnection()
        {
            OracleConnection conn = new OracleConnection(connStr);
            conn.Open();
            return conn;
        }

        /// <summary>
        /// 使用亦有链接的 非查询
        /// </summary>
        /// <param name="conn">链接</param>
        /// <param name="sql">sql文本</param>
        /// <param name="parameters">sql参数</param>
        /// <returns>受影响行数</returns>
        public static int ExecuteNonQuery(OracleConnection conn, string sql, params OracleParameter[] parameters)
        {
            using (OracleCommand cmd = new OracleCommand(sql, conn))
            {
                cmd.Parameters.AddRange(parameters);
                return cmd.ExecuteNonQuery();
            }
        }

        /// <summary>
        /// 自己创建链接的 非查询
        /// </summary>
        /// <param name="sql">sql文本</param>
        /// <param name="parameters">sql参数</param>
        /// <returns>受影响行数</returns>
        public static int ExecuteNonQuery(string sql, params OracleParameter[] parameters)
        {
            using (OracleConnection conn = CreateConnection())
            {
                return ExecuteNonQuery(conn, sql, parameters);
            }
        }

        /// <summary>
        /// 使用已有链接的 带存储过程的Insert非查询，直接写存储过程参数
        /// </summary>
        /// <param name="conn">已有链接</param>
        /// <param name="proName">存储过程名称</param>
        /// <param name="strInsertSQL">执行插入的sql语句，或者其他操作sql语句</param>
        /// <param name="seqName">序列的名称</param>
        /// <returns>当前序列号，即ID</returns>
        public static object ExecuteNonQueryWithProduce(OracleConnection conn, string proName, string strInsertSQL, string seqName)
        {
            using (OracleCommand cmd = new OracleCommand(proName, conn)) //命令中执行的不在是sql，而是存储过程
            {
                try
                {
                    cmd.CommandType = CommandType.StoredProcedure; //标记该命令的类型不是sql，而是存储过程
                    //存储过程中有参数名称，以及设置对应参数的值
                    cmd.Parameters.Add(new OracleParameter("strInsertSQL", OracleDbType.Varchar2) { Value = strInsertSQL }); ////存储过程中的参入参数 strInsertSQL
                    cmd.Parameters.Add(new OracleParameter("seqName", OracleDbType.Varchar2) { Value = seqName }); // //存储过程中的传入参数 seqName
                    cmd.Parameters.Add(new OracleParameter("ID", OracleDbType.Int32) { Direction = ParameterDirection.Output }); //存储过程中的传出参数ID，只需要声明
                    //cmd.Parameters.AddRange(parameters);
                    cmd.ExecuteNonQuery();
                    string newId = cmd.Parameters["ID"].Value.ToString(); //获得传出参数的ID的值
                    return newId;
                }
                catch (Exception ex)
                {
                    throw new Exception(ex.ToString());
                }
            }
        }

        /// <summary>
        /// 自己创建链接的 带存储过程的Insert非查询，直接写存储过程参数
        /// </summary>
        /// <param name="proName">存储过程名称</param>
        /// <param name="strInsertSQL">执行插入的sql语句，或者其他操作sql语句</param>
        /// <param name="seqName">序列的名称</param>
        /// <returns>当前序列号，即ID</returns>
        public static object ExecuteNonQueryWithProduce(string proName, string strInsertSQL, string seqName)
        {
            using (OracleConnection conn = CreateConnection())
            {
                return ExecuteNonQueryWithProduce(conn, proName, strInsertSQL, seqName);
            }
        }

        /// <summary>
        /// 使用已有链接的 带存储过程的Insert非查询，传存储过程参数
        /// </summary>
        /// <param name="conn">已有链接</param>
        /// <param name="proName">存储过程名称</param>
        /// <param name="parameters">存储过程中的传入、传出参数 数组</param>
        /// <returns>当前序列号，即ID</returns>
        public static object ExecuteNonQueryWithProduce(OracleConnection conn, string proName, params OracleParameter[] parameters)
        {
            using (OracleCommand cmd = new OracleCommand(proName, conn)) //命令中执行的不在是sql，而是存储过程
            {
                //try
                //{
                cmd.CommandType = CommandType.StoredProcedure; //标记该命令的类型不是sql，而是存储过程
                ////存储过程中有参数名称，以及设置对应参数的值
                //cmd.Parameters.Add(new OracleParameter("strInsertSQL", OracleDbType.Varchar2) { Value = strInsertSQL }); ////存储过程中的参入参数 strInsertSQL
                //cmd.Parameters.Add(new OracleParameter("seqName", OracleDbType.Varchar2) { Value = seqName }); // //存储过程中的传入参数 seqName
                //cmd.Parameters.Add(new OracleParameter("ID", OracleDbType.Int32) { Direction = ParameterDirection.Output }); //存储过程中的传出参数ID，只需要声明
                cmd.Parameters.AddRange(parameters); //参数中包括存储过程的传入传出参数，以及子sql语句中的参数    --------------****-----------------
                int i = cmd.ExecuteNonQuery(); //直接返回执行插入之后，存储过程传出的变量值
                object newId = cmd.Parameters["ID"].Value; //获得传出参数的ID的值
                return newId;
                //}
                //catch (Exception ex)
                //{
                //    throw new Exception(ex.ToString());
                //}
            }
        }

        /// <summary>
        /// 自己创建链接的 带存储过程的Insert非查询，传存储过程参数
        /// </summary>
        /// <param name="proName">存储过程名称</param>
        /// <param name="parameters">存储过程中的传入、传出参数 数组</param>
        /// <returns>当前序列号，即ID</returns>
        public static object ExecuteNonQueryWithProduce(string proName, params OracleParameter[] parameters)
        {
            using (OracleConnection conn = CreateConnection())
            {
                return ExecuteNonQueryWithProduce(conn, proName, parameters);
            }
        }


        /// <summary>
        /// 使用已有链接的 单查询
        /// </summary>
        /// <param name="conn">链接</param>
        /// <param name="sql">sql文本</param>
        /// <param name="parameters">sql参数</param>
        /// <returns>查询到的一条结果</returns>
        public static object ExecuteScalar(OracleConnection conn, string sql, params OracleParameter[] parameters)
        {
            using (OracleCommand cmd = new OracleCommand(sql, conn))
            {
                cmd.Parameters.AddRange(parameters);
                return cmd.ExecuteScalar();
            }
        }

        /// <summary>
        /// 自己创建链接的 单查询
        /// </summary>
        /// <param name="sql">sql文本</param>
        /// <param name="parameters">sql参数</param>
        /// <returns>查询到的一条结果</returns>
        public static object ExecuteScalar(string sql, params OracleParameter[] parameters)
        {
            using (OracleConnection conn = CreateConnection())
            {
                return ExecuteScalar(conn, sql, parameters);
            }
        }

        /// <summary>
        /// 使用已有链接的 reader查询
        /// </summary>
        /// <param name="conn">链接</param>
        /// <param name="sql">sql文本</param>
        /// <param name="parameters">sql参数</param>
        /// <returns>查询到的结果集table</returns>
        public static DataTable ExecuteReader(OracleConnection conn, string sql, params OracleParameter[] parameters)
        {
            DataTable table = new DataTable();
            using (OracleCommand cmd = new OracleCommand(sql, conn))
            {
                cmd.Parameters.AddRange(parameters);
                using (OracleDataReader reader = cmd.ExecuteReader())
                {
                    table.Load(reader);
                }
            }
            return table;
        }

        /// <summary>
        /// 自己创建链接的 reader查询
        /// </summary>
        /// <param name="sql">sql文本</param>
        /// <param name="parameters">sql参数</param>
        /// <returns>查询到的结果集table</returns>
        public static DataTable ExecuteReader(string sql, params OracleParameter[] parameters)
        {
            using (OracleConnection conn = CreateConnection())
            {
                return ExecuteReader(conn, sql, parameters);
            }
        }

        /// <summary>
        /// 使用已有链接的 stream查询
        /// </summary>
        /// <param name="conn">链接</param>
        /// <param name="sql">sql文本</param>
        /// <param name="parameters">sql参数</param>
        /// <returns>查询到的结果流stream</returns>
        public static System.IO.Stream ExecuteStream(OracleConnection conn, string sql, params OracleParameter[] parameters)
        {
            using (OracleCommand cmd = new OracleCommand(sql, conn))
            {
                cmd.Parameters.AddRange(parameters);
                using (System.IO.Stream stream = cmd.ExecuteStream())
                {
                    return stream;
                }
            }
        }

        /// <summary>
        /// 自己创建链接的stream查询
        /// </summary>
        /// <param name="sql">sql文本</param>
        /// <param name="parameters">sql参数</param>
        /// <returns>查询到的结果流stream</returns>
        public static System.IO.Stream ExecuteStream(string sql, params OracleParameter[] parameters)
        {
            using (OracleConnection conn = CreateConnection())
            {
                return ExecuteStream(conn, sql, parameters);
            }
        }
    }

DbHelper.cs

public class DbHelper 
    {
        private static readonly string connStr = ConfigurationManager.ConnectionStrings["dbconnStr"].ConnectionString;

        //创建连接
        public static IDbConnection CreateConnection()
        {
            IDbConnection conn = new OracleConnection(connStr);
            conn.Open();
            return conn;
        }

        //把字典中的参数都加入到cmd得参数集合中
        public static void DictAddToCmdParameters(IDbCommand cmd,Dictionary<string,object> dict)
        { 
            foreach(KeyValuePair<string,object> kvp in dict)
            {
                IDataParameter parameters = cmd.CreateParameter();
                parameters.ParameterName = kvp.Key;
                parameters.Value = kvp.Value;
                cmd.Parameters.Add(parameters);
            }
        }

        //使用已有连接的 非查询
        public static int ExecuteNonQuery(IDbConnection conn,string sql,Dictionary<string,object> dict)
        { 
            using(IDbCommand cmd=conn.CreateCommand())
            {
                cmd.CommandText = sql;
                DictAddToCmdParameters(cmd, dict);
                return cmd.ExecuteNonQuery();
            }
        }

        //使用已有连接的 非查询 带事务处理
        public static int ExecuteNonQuery(IDbConnection conn,IDbTransaction tx,string sql,Dictionary<string,object> dict)
        { 
            using(IDbCommand cmd=conn.CreateCommand())
            {
                cmd.Transaction = tx;
                cmd.CommandText = sql;
                DictAddToCmdParameters(cmd, dict);
                return cmd.ExecuteNonQuery();
            }
        }

        //自己创建连接的 非查询
        public static int ExecuteNonQuery(string sql,Dictionary<string,object> dict)
        {
            using(IDbConnection conn=CreateConnection())
            {
                return ExecuteNonQuery(sql,dict);
            }
        }

        //使用已有连接的 单查询
        public static object ExecuteScalar(IDbConnection conn,string sql,Dictionary<string,object> dict)
        { 
            using(IDbCommand cmd=conn.CreateCommand())
            {
                cmd.CommandText = sql;
                DictAddToCmdParameters(cmd, dict);
                return cmd.ExecuteScalar();
            }
        }

        //自己创建连接的 单查询
        public static object ExecuteScalar(string sql,Dictionary<string,object> dict)
        { 
            using(IDbConnection conn=CreateConnection())
            {
                return ExecuteScalar(conn, sql, dict);
            }
        }

        //使用已有连接的 Reader查询
        public static DataTable ExecuteReader(IDbConnection conn,string sql,Dictionary<string,object> dict)
        {
            DataTable table = new DataTable();
            using(IDbCommand cmd=conn.CreateCommand())
            {
                cmd.CommandText = sql;
                DictAddToCmdParameters(cmd, dict);
                using (IDataReader reader = cmd.ExecuteReader())
                {
                    table.Load(reader);
                }
            }
            return table;
        }

        //自己创建连接的 Reader查询 
        public static DataTable ExecuteReader(string sql,Dictionary<string,object> dict)
        { 
            using(IDbConnection conn=CreateConnection())
            {
                return ExecuteReader(conn, sql, dict);
            }
        }

        //使用已有连接的 DataAdapter查询
        public static DataTable ExecuteDataAdapter(IDbConnection conn,string sql,Dictionary<string,object> dict)
        { 
            using(IDbCommand cmd=conn.CreateCommand())
            {
                cmd.CommandText = sql;
                DictAddToCmdParameters(cmd, dict);
                IDataAdapter adapter = GetDataAdapter(cmd);//获得查询的数据库结果
                DataSet dataset = new DataSet();
                adapter.Fill(dataset);
                return dataset.Tables[0];
            }
        }

        //自己创建连接的 DataAdapter查询
        public static DataTable ExecuteDataAdapter(string sql,Dictionary<string,object> dict)
        { 
            using(IDbConnection conn=CreateConnection())
            {
                return ExecuteDataAdapter(conn, sql, dict);
            }
        }

        //获得查询到的数据库结果
        private static IDataAdapter GetDataAdapter(IDbCommand cmd)
        {
            IDataAdapter adapter;//DataAdapter的访问限制为protected,不能new
            if (cmd is OracleCommand)//需引用Oracle.DataAccess.Client
            {
                OracleCommand oracmd = cmd as OracleCommand;
                adapter = new OracleDataAdapter(oracmd);
            }
            //else if (cmd is MySqlCommand)//需引用mysql.data.client
            //{
            //    MySqlCommand mycom = cmd as MySqlCommand;
            //    adapter = new MySqlDataAdapter(mycom);
            //}
            else if (cmd is SqlCommand)//需引用System.Data.SqlClient;
            {
                SqlCommand sqlcom = cmd as SqlCommand;
                adapter = new SqlDataAdapter(sqlcom);
            }
            else
            {
                throw new Exception("需要其他数据库的DataAdapter");
            }
            return adapter;
        }

        /// <summary>
        /// 执行SqlBulkCopy或OracleBulkCopy批量拷贝，传入一个实体的公共类型，约定其属性名与DB中列名相同
        /// </summary>
        /// <param name="type"></param>
        /// <returns>返回该类型对应的表的架构</returns>
        public static DataTable ExecuteBulkCopy(Type type)
        {
            //创建表的架构
            DataTable table = new DataTable();
            DataColumn column = new DataColumn();
            //Type type = typeof(Person);//传入实体类Person
            PropertyInfo[] properties = type.GetProperties();
            //创建表的列
            foreach (PropertyInfo property in properties)
            {
                column.ColumnName = property.Name;
                column.DataType = property.PropertyType;
                table.Columns.Add(column);
            }
            return table;
        }

        /// <summary>
        /// 遍历： 把每个数据中数据依次填充到该表的row中
        /// </summary>
        /// <param name="table"></param>
        /// <param name="type"></param>
        /// <param name="line"></param>
        /// <returns>返回填充了一行数据的表</returns>
        public static DataTable RowAddTable(DataTable table, Type type, string[] line)//line中个数必须与列数量相同
        {
            //填入表的行
            DataRow row = table.NewRow();
            PropertyInfo[] properties = type.GetProperties();
            int i = 0;
            foreach (PropertyInfo property in properties)//属性名对应列名
            {
                row[property.Name] = line[i];
                i++;
            }
            table.Rows.Add(row);
            return table;
        }

        /// <summary>
        /// 把当前表写入目标表（目标表和当前表列名相同）
        /// </summary>
        /// <param name="destTableName"></param>
        /// <param name="currentTabele"></param>
        public static bool BulkCopyMapping(string destTableName, DataTable currentTabele)
        {
            bool falg = false;
            //using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connStr))
            using (OracleBulkCopy bulkCopy = new OracleBulkCopy(connStr))//oracle在这里不能用事务,sql server可以
            {
                
                bulkCopy.DestinationTableName = destTableName;
                foreach (DataColumn column in currentTabele.Columns)
                {
                    bulkCopy.ColumnMappings.Add(column.ColumnName, column.ColumnName);//目标表和当前表列名相同
                }
                try
                {
                    bulkCopy.WriteToServer(currentTabele);//把当前表写入目标表
                    falg = true;
                }
                catch (Exception ex)
                {
                    falg = false;
                    throw new Exception(ex.ToString());
                }
            }
            return falg;
        }
    }
    class Person//BulkCopy直接传了Type所以没用到
    {
        public int Id{get;set;}
        public string Name{get;set;}
    }