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);
             }
         }
     }

OracleHelper.cs

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[];
             }
         }

         //自己创建连接的 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 = ;
             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;}
     }

DbHelper.cs