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

DbHelper.cs