.Net 下数据库操作类库
2008-08-02 14:30
381 查看
现在3层开发模式里面表示层， 业务逻辑层， 数据访问层
现在把数据访问层封装起来做为Class ，实现对数据进行访问的数据库操作类
下面是结构组件图
先从一个程序说起，再慢慢深入的理解数据操作类的实现
private void ConnectionDataBase()
{
//连接数据库
CommonInterface pObj_Comm=CommonFactory.CreateInstance(CommonData.sql);
string str_sql="select Guid,ReportID,ReportCompID,ReportFlag,QryConditionID from ReportMain ";
DataTable dt=pObj_Comm.ExeForDtl(str_sql);
pObj_Comm.Close();
MessageBox.Show(dt.Rows.Count.ToString());
}
首先 CommonInterface pObj_Comm=CommonFactory.CreateInstance(CommonData.sql);
调用CommonFactory里面的静态方法 public static CommonInterface CreateInstance(CommonData CommonData_Parameter)
其中 CommonData 是枚举类型
/// <summary>
/// 数据访问类型
/// </summary>
public enum CommonData
{
/// <summary>
/// 以SQL Server方式
/// </summary>
sql = 1,
/// <summary>
/// 以OLEDB方式
/// </summary>
oledb = 2,
} ;
当
case 1:
return new CommonSql();
实例化CommonSql 返回的是CommonInterface 接口类型
CommonInterface 的定义如下：public interface CommonInterface
新建立一个类库 MySql.Pantheon.DAO
1 数据库连接
namespace MySql.Pantheon.DAO
{
/**//// <summary>
/// 作用: 设置数据库默认连接字符串的配置类。
/// 作者:
/// 编写日期:
/// </summary>
public class CommonDataConfig
{
/**//// <summary>
/// 数据库连接字符串
/// </summary>
///<example>使用此静态连接字符串的示例：
/// <code>
/// using MySql.Pantheon.DAO;
/// //设定DAO所要使用的连接参数
/// public static string ConnectionDefaultStrserver=192.168.0.220;database=pantheon;uid=pantheon;pwd=pantheon2002="server=server-test1;database=kmp50;uid=kmp;pwd=123123123";
/// </code>
///</example>
public static string ConnectionDefaultStr = "server=JHTCHINA;database=LGBMISEXT;uid=sa;pwd=jhtchina";
}
}
2 确定访问方式的确定 SQL 方式 还是Oledb方式
using System;
namespace MySql.Pantheon.DAO
{
/**//// <summary>
/// 数据访问类型
/// </summary>
public enum CommonData
{
/**//// <summary>
/// 以SQL Server方式
/// </summary>
sql = 1,
/**//// <summary>
/// 以OLEDB方式
/// </summary>
oledb = 2,
} ;
/**//// <summary>
/// 作用: 数据库访问工厂类
/// 作者:
/// 编写日期:
/// 修改日期：加入代码示例程序
/// </summary>
public class CommonFactory
{
/**//// <summary>
/// 是否单例模式连接
/// </summary>
public static bool IsSingleConnection = false;
/**//// <summary>
/// winForm下的单例模式连接对象 修改:吴炜
/// </summary>
public static CommonInterface SingleConnection;
/**//// <summary>
/// 创建一个数据访问接口,默认返回SQL类型的数据访问接口
/// </summary>
/// <param name="CommonData_Parameter">数据访问类型</param>
/// <returns>CommonInterface接口</returns>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql);
/// </code>
/// </example>
public static CommonInterface CreateInstance(CommonData CommonData_Parameter)
{
switch ((int) CommonData_Parameter)
{
case 1:
return new CommonSql();
case 2:
return new CommonOle();
default:
return new CommonSql();
}
}
/**//// <summary>
/// 创建一个数据访问接口
/// </summary>
/// <param name="CommonData_Parameter">数据访问类型</param>
/// <param name="connstr">数据库的连接串</param>
/// <returns>CommonInterface接口</returns>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// string pConnectionString="";
///
/// pConnectionString="server=192.168.0.220;database=pantheon;uid=pantheon;pwd=pantheon2002";
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
/// </code>
/// </example>
public static CommonInterface CreateInstance(CommonData CommonData_Parameter, String connstr)
{
switch ((int) CommonData_Parameter)
{
case 1:
return new CommonSql(connstr);
case 2:
return new CommonOle(connstr);
default:
return new CommonSql(connstr);
}
}
}
}
3 对数据库通用操作的接口进行定义
using System;
using System.Data;
namespace MySql.Pantheon.DAO
{
/**//// <summary>
/// 作用:对数据库通用操作的接口。
/// 作者:
/// 修改：
/// </summary>
public interface CommonInterface
{
/**//// <summary>
/// 开始一个事务
/// </summary>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// //
/// //进行一些数据访问操作的代码
/// //
///
/// //提交本次的事务
/// pComm.CommitTrans();
///
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
void BeginTrans();
/**//// <summary>
/// 提交一个事务
/// </summary>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// //
/// //进行一些数据访问操作的代码
/// //
///
/// //提交本次的事务
/// pComm.CommitTrans();
///
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
void CommitTrans();
/**//// <summary>
/// 回滚一个事务
/// </summary>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// try
/// {
/// //
/// //进行一些数据访问操作的代码
/// //
///
/// //提交本次的事务
/// pComm.CommitTrans();
///
/// //关闭数据库连结
/// pComm.Close();
/// }
/// catch(Exception ex)
/// {
/// //
/// //自己的处理
/// //
///
/// //回滚此次数据操作
/// pComm.RollbackTrans();
///
/// //关闭数据库连结
/// pComm.Close();
/// }
///
/// </code>
/// </example>
void RollbackTrans();
/**//// <summary>
/// 执行SQL语句
/// </summary>
/// <param name="sql">SQL语句</param>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// //进行一些数据访问操作的代码
/// string pSql="";
///
/// pSql="select * from YourTable";
///
/// //执行此次数据操作
/// pComm.Execute(pSql);
///
/// //提交本次的事务
/// pComm.CommitTrans();
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
void Execute(String sql);
/**//// <summary>
/// 执行SQL语句，填充到指定的DataTable中，返回DataSet
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <param name="strTable">DataTable的名称</param>
/// <returns>DataSet数据集和</returns>
DataSet ExeForDst(String QueryString, String strTable);
/**//// <summary>
/// 执行一段SQL语句，返回DataSet结果集
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <returns>DataSet结果集</returns>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// string pSql="";
/// DataSet pDst=new DataSet();
///
/// //进行一些数据访问操作的代码
/// pSql="select * from YourTable";
///
/// //执行此次数据操作
/// pDst=pComm.ExeForDst(pSql);
///
/// //提交本次的事务
/// pComm.CommitTrans();
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
DataSet ExeForDst(String QueryString);
/**//// <summary>
/// 执行SQL语句，返回DataTable
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <param name="TableName">DataTable的名称</param>
/// <returns>DataTable的结果集</returns>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// string pSql="";
/// DataTable pDst=new DataTable();
///
/// //进行一些数据访问操作的代码
/// pSql="select * from YourTable";
///
/// //执行此次数据操作
/// pDst=pComm.ExeForDtl(pSql,"UserInfo");
///
/// //提交本次的事务
/// pComm.CommitTrans();
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
DataTable ExeForDtl(String QueryString, String TableName);
/**//// <summary>
/// 执行SQL语句，返回默认DataTable
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <returns>DataTable结果集</returns>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// string pSql="";
/// DataTable pDst=new DataTable();
///
/// //进行一些数据访问操作的代码
/// pSql="select * from YourTable";
///
/// //执行此次数据操作
/// pDst=pComm.ExeForDtl(pSql);
///
/// //提交本次的事务
/// pComm.CommitTrans();
///
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
DataTable ExeForDtl(String QueryString);
/**//// <summary>
/// 执行SQL语句，返回IDataReader接口
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <returns>IDataReader接口</returns>
IDataReader ExeForDtr(String QueryString);
/**//// <summary>
/// 返回IDbCommand接口
/// </summary>
/// <returns>IDbCommand接口</returns>
IDbCommand GetCommand();
/**//// <summary>
/// 关闭数据库连接
/// </summary>
void Close();
/**//// <summary>
/// 用来执行带有参数的SQL语句（不是存储过程）
/// </summary>
/// <param name="SQLText">带有参数的SQL语句</param>
/// <param name="Parameters">传递的参数列表</param>
/// <param name="ParametersValue">同参数列表对应的参数值列表</param>
void ExecuteNonQuery(string SQLText, string[] Parameters, string[] ParametersValue);
/**//// <summary>
/// 执行存储过程
/// </summary>
/// <param name="StoredProcedureName">存储过程的名称</param>
/// <param name="Parameters">传递的参数列表</param>
/// <param name="ParametersValue">同参数列表对应的参数值列表</param>
/// <param name="ParametersType">同参数列表对应的参数类型列表</param>
void ExecuteSP(string StoredProcedureName, string[] Parameters, string[] ParametersValue, string[] ParametersType);
/**////<summary>
/// 执行存储过程,得到结果集DataSet
/// </summary>
/// <param name="sqname">存储过程名称</param>
/// <param name="array">参数名称与值的数组</param>
/// <returns>返回True或False</returns>
DataSet ExcuteSp(string sqname, string[,] array);
/**//// <summary>
///
/// </summary>
/// <param name="QueryString"></param>
/// <returns></returns>
object ExecuteScalar(String QueryString);
/**//// <summary>
///
/// </summary>
/// <param name="sql"></param>
/// <returns></returns>
IDataAdapter getDataAdapter(string sql);
/**//// <summary>
///
/// </summary>
/// <returns></returns>
ICommandBuilder getCommandBuilder();
}
}
mssql的数据库连结方式的类 里面有定义实现方式
using System;
using System.Data;
using System.Data.SqlClient;
namespace MySql.Pantheon.DAO
{
/**//// <summary>
/// 作用:mssql的数据库连结方式的类
/// 作者:
/// 编写日期:
/// 修改1：
/// 1、将类声明的修饰符修改为“internal”，防止直接new此类
/// 2、增加对存储过程的封装
///
internal class CommonSql : CommonInterface
{
private SqlConnection conn = null;
private SqlCommand cmd = null;
private SqlTransaction trans = null;
private String connstr = null;
/**//// <summary>
/// 构造方法
/// </summary>
public CommonSql()
{
connstr = CommonDataConfig.ConnectionDefaultStr;
Initial();
}
/**//// <summary>
/// 带有参数的构造方法
/// </summary>
/// <param name="ConnStr_Param">数据库连接字符串</param>
public CommonSql(String ConnStr_Param)
{
connstr = ConnStr_Param;
Initial();
}
/**//// <summary>
/// 初始化
/// </summary>
private void Initial()
{
try
{
if (connstr == null)
{
}
this.conn = new SqlConnection(connstr);
this.cmd = new SqlCommand();
cmd.Connection = this.conn;
this.conn.Open();
}
catch (Exception e)
{
throw e;
}
}
/**//// <summary>
/// 开始一个事务
/// </summary>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// //
/// //进行一些数据访问操作的代码
/// //
///
/// //提交本次的事务
/// pComm.CommitTrans();
///
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
public void BeginTrans()
{
trans = conn.BeginTransaction();
cmd.Transaction = trans;
}
/**//// <summary>
/// 提交一个事务
/// </summary>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// //
/// //进行一些数据访问操作的代码
/// //
///
/// //提交本次的事务
/// pComm.CommitTrans();
///
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
public void CommitTrans()
{
trans.Commit();
}
/**//// <summary>
/// 回滚一个事务
/// </summary>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// try
/// {
/// //
/// //进行一些数据访问操作的代码
/// //
///
/// //提交本次的事务
/// pComm.CommitTrans();
///
/// //关闭数据库连结
/// pComm.Close();
/// }
/// catch(Exception ex)
/// {
/// //
/// //自己的处理
/// //
///
/// //回滚此次数据操作
/// pComm.RollbackTrans();
///
/// //关闭数据库连结
/// pComm.Close();
/// }
///
/// </code>
/// </example>
public void RollbackTrans()
{
trans.Rollback();
}
/**//// <summary>
/// 执行SQL语句
/// </summary>
/// <param name="sql">SQL语句</param>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// //进行一些数据访问操作的代码
/// string pSql="";
///
/// pSql="select * from YourTable";
///
/// //执行此次数据操作
/// pComm.Execute(pSql);
///
/// //提交本次的事务
/// pComm.CommitTrans();
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
public void Execute(String sql)
{
try
{
cmd.CommandText = sql;
cmd.ExecuteNonQuery();
}
catch (Exception e)
{
throw e;
}
}
/**//// <summary>
/// 执行SQL语句，填充到指定的DataTable中，返回DataSet
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <param name="strTable">DataTable的名称</param>
/// <returns>DataSet数据集和</returns>
public DataSet ExeForDst(String QueryString, String strTable)
{
DataSet ds = new DataSet();
SqlDataAdapter ad = new SqlDataAdapter();
cmd.CommandText = QueryString;
修改1#region 修改1
if (QueryString.Length>40000)
{
cmd.CommandTimeout=300;
}
#endregion
try
{
ad.SelectCommand = cmd;
ad.Fill(ds, strTable);
}
catch (Exception e)
{
throw e;
}
return ds;
}
/**//// <summary>
/// 执行一段SQL语句，返回DataSet结果集
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <returns>DataSet结果集</returns>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// string pSql="";
/// DataSet pDst=new DataSet();
///
/// //进行一些数据访问操作的代码
/// pSql="select * from YourTable";
///
/// //执行此次数据操作
/// pDst=pComm.ExeForDst(pSql);
///
/// //提交本次的事务
/// pComm.CommitTrans();
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
public DataSet ExeForDst(String QueryString)
{
DataSet ds = new DataSet();
SqlDataAdapter ad = new SqlDataAdapter();
cmd.CommandText = QueryString;
修改2#region 修改2
if (QueryString.Length>40000)
{
cmd.CommandTimeout=300;
}
#endregion
try
{
ad.SelectCommand = cmd;
ad.Fill(ds);
}
catch (Exception e)
{
throw e;
}
return ds;
}
/**//// <summary>
/// 执行SQL语句，返回DataTable
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <param name="TableName">DataTable的名称</param>
/// <returns>DataTable的结果集</returns>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// string pSql="";
/// DataTable pDst=new DataTable();
///
/// //进行一些数据访问操作的代码
/// pSql="select * from YourTable";
///
/// //执行此次数据操作
/// pDst=pComm.ExeForDtl(pSql,"UserInfo");
///
/// //提交本次的事务
/// pComm.CommitTrans();
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
public DataTable ExeForDtl(String QueryString, String TableName)
{
try
{
DataSet ds;
DataTable dt;
ds = ExeForDst(QueryString, TableName);
dt = ds.Tables[TableName];
ds = null;
return dt;
}
catch
{
throw;
}
finally
{
}
}
/**//// <summary>
/// 执行SQL语句，返回默认DataTable
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <returns>DataTable结果集</returns>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// string pSql="";
/// DataTable pDst=new DataTable();
///
/// //进行一些数据访问操作的代码
/// pSql="select * from YourTable";
///
/// //执行此次数据操作
/// pDst=pComm.ExeForDtl(pSql);
///
/// //提交本次的事务
/// pComm.CommitTrans();
///
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
public DataTable ExeForDtl(String QueryString)
{
try
{
DataSet ds;
DataTable dt;
ds = ExeForDst(QueryString);
dt = ds.Tables[0];
ds = null;
return dt;
}
catch (Exception ee)
{
throw new Exception(ee.Message);
}
finally
{
}
}
/**//// <summary>
/// 执行SQL语句，返回IDataReader接口
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <returns>IDataReader接口</returns>
public IDataReader ExeForDtr(String QueryString)
{
try
{
cmd.CommandText = QueryString;
return cmd.ExecuteReader();
}
catch
{
throw;
}
}
/**//// <summary>
/// 返回IDbCommand接口
/// </summary>
/// <returns>IDbCommand接口</returns>
public IDbCommand GetCommand()
{
try
{
return this.cmd;
}
catch (Exception e)
{
throw e;
}
}
/**//// <summary>
/// 返回IDbConnection接口
/// </summary>
/// <returns>IDbConnection接口</returns>
public IDbConnection GetConn()
{
return this.conn;
}
/**//// <summary>
/// 关闭数据库连接
/// </summary>
public void Close()
{
if (conn.State.ToString().ToUpper() == "OPEN")
{
this.conn.Close();
}
}
/**//// <summary>
/// 用来执行带有参数的SQL语句（不是存储过程）
/// </summary>
/// <param name="SQLText">带有参数的SQL语句</param>
/// <param name="Parameters">传递的参数列表</param>
/// <param name="ParametersValue">同参数列表对应的参数值列表</param>
public void ExecuteNonQuery(string SQLText, string[] Parameters, string[] ParametersValue)
{
try
{
this.cmd.CommandText = SQLText;
for (int i = 0; i < Parameters.Length; i++)
{
this.cmd.Parameters.Add("@" + Parameters[i].ToString(), ParametersValue[i].ToString());
}
this.cmd.ExecuteNonQuery();
}
catch (Exception e)
{
throw e;
}
}
/**//// <summary>
/// 执行存储过程
/// </summary>
/// <param name="StoredProcedureName">存储过程的名称</param>
/// <param name="Parameters">传递的参数列表</param>
/// <param name="ParametersValue">同参数列表对应的参数值列表</param>
/// <param name="ParametersType">同参数列表对应的参数类型列表</param>
public void ExecuteSP(string StoredProcedureName, string[] Parameters, string[] ParametersValue, string[] ParametersType)
{
try
{
this.cmd.CommandText = StoredProcedureName;
this.cmd.CommandType = CommandType.StoredProcedure;
for (int i = 0; i < Parameters.Length; i++)
{
SqlParameter myParm = this.cmd.Parameters.Add("@" + Parameters[i], ParametersType[i].ToString());
myParm.Value = ParametersValue[i];
}
this.cmd.ExecuteNonQuery();
}
catch (Exception e)
{
throw e;
}
}
/**////<summary>
/// 执行存储过程,得到结果集DataSet
/// </summary>
/// <param name="sqname">存储过程名称</param>
/// <param name="array">参数名称与值的数组</param>
/// <returns>返回True或False</returns>
public DataSet ExcuteSp(string sqname, string[,] array)
{
try
{
DataSet dset = new DataSet();
SqlDataAdapter dp = new SqlDataAdapter();
SqlCommand cmmd = new SqlCommand();
dp.SelectCommand = cmmd;
dp.SelectCommand.Connection = this.conn;
dp.SelectCommand.CommandType = CommandType.StoredProcedure;
dp.SelectCommand.CommandText = sqname;
for (int i = 0; i <= array.GetUpperBound(0); i++)
{
if (array[i, 0] != null)
{
SqlParameter Parm = dp.SelectCommand.Parameters.Add(array[i, 0].ToString(), SqlDbType.NVarChar);
Parm.Value = array[i, 1].ToString();
}
}
dp.Fill(dset, "Default");
return dset;
}
catch (Exception e)
{
throw e;
}
}
public object ExecuteScalar(string QueryString)
{
cmd.CommandText = QueryString;
try
{
return cmd.ExecuteScalar();
}
catch (Exception e)
{
throw e;
}
// return null;;
}
public IDataAdapter getDataAdapter(string sql)
{
return new SqlDataAdapter(sql, this.conn);
}
public ICommandBuilder getCommandBuilder()
{
return new SqlCmdBuilder();
}
}
}
OLEDB的数据库连结方式的类 实现对OLEDB的各种操作
using System;
using System.Data;
using System.Data.OleDb;
namespace MySql.Pantheon.DAO
{
/**//// <summary>
/// 作用:OLEDB的数据库连结方式的类
/// 作者:
/// 修改：
/// 编写日期:
/// </summary>
internal class CommonOle : CommonInterface
{
/**//// <summary>
/// 默认的构造方法
/// </summary>
public CommonOle()
{
connstr = CommonDataConfig.ConnectionDefaultStr;
Initial();
}
/**//// <summary>
/// 带有参数的构造方法
/// </summary>
/// <param name="Connstr_Param">数据库连接字符串</param>
public CommonOle(String Connstr_Param)
{
connstr = Connstr_Param;
Initial();
}
/**//// <summary>
/// 初始化
/// </summary>
private void Initial()
{
try
{
if (connstr == null)
{
//throw(new CommonException("连接字符串没有在web.config里设置"));
}
this.conn = new OleDbConnection(connstr);
this.cmd = new OleDbCommand();
cmd.Connection = this.conn;
this.conn.Open();
}
catch (Exception e)
{
throw e;
}
}
private OleDbConnection conn = null;
private OleDbCommand cmd = null;
private OleDbTransaction trans = null;
private String connstr = null;
/**//// <summary>
/// 开始一个事务
/// </summary>
public void BeginTrans()
{
trans = conn.BeginTransaction();
cmd.Transaction = trans;
}
/**//// <summary>
/// 提交一个事务
/// </summary>
public void CommitTrans()
{
trans.Commit();
}
/**//// <summary>
/// 回滚一个事务
/// </summary>
public void RollbackTrans()
{
trans.Rollback();
}
/**//// <summary>
/// 执行一条SQL语句
/// </summary>
/// <param name="sql"></param>
public void Execute(String sql)
{
try
{
cmd.CommandText = sql;
cmd.ExecuteNonQuery();
}
catch (Exception e)
{
throw e;
}
}
/**//// <summary>
/// 执行SQL语句，填充到指定的DataTable中，返回DataSet
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <param name="strTable">DataTable的名称</param>
/// <returns>DataSet数据集和</returns>
public DataSet ExeForDst(String QueryString, String strTable)
{
DataSet ds = new DataSet();
OleDbDataAdapter ad = new OleDbDataAdapter();
cmd.CommandText = QueryString;
try
{
ad.SelectCommand = cmd;
ad.Fill(ds, strTable);
}
catch (Exception e)
{
throw e;
}
return ds;
}
/**//// <summary>
/// 执行一段SQL语句，返回DataSet结果集
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <returns>DataSet结果集</returns>
public DataSet ExeForDst(String QueryString)
{
DataSet ds = new DataSet();
OleDbDataAdapter ad = new OleDbDataAdapter();
cmd.CommandText = QueryString;
try
{
ad.SelectCommand = cmd;
ad.Fill(ds);
}
catch (Exception e)
{
throw e;
}
return ds;
}
/**//// <summary>
/// 执行SQL语句，返回DataTable
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <param name="TableName">DataTable的名称</param>
/// <returns>DataTable的结果集</returns>
public DataTable ExeForDtl(String QueryString, String TableName)
{
try
{
DataSet ds;
DataTable dt;
ds = ExeForDst(QueryString, TableName);
dt = ds.Tables[TableName];
ds = null;
return dt;
}
catch
{
throw;
}
finally
{
}
}
/**//// <summary>
/// 执行SQL语句，返回默认DataTable
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <returns>DataTable结果集</returns>
public DataTable ExeForDtl(String QueryString)
{
try
{
DataSet ds;
DataTable dt;
ds = ExeForDst(QueryString);
dt = ds.Tables[0];
ds = null;
return dt;
}
catch
{
throw;
}
finally
{
}
}
/**//// <summary>
/// 执行SQL语句，返回IDataReader接口
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <returns>IDataReader接口</returns>
public IDataReader ExeForDtr(String QueryString)
{
try
{
cmd.CommandText = QueryString;
return cmd.ExecuteReader();
}
catch
{
throw;
}
}
/**//// <summary>
/// 返回IDbCommand接口
/// </summary>
/// <returns>IDbCommand接口</returns>
public IDbCommand GetCommand()
{
try
{
return this.cmd;
}
catch (Exception e)
{
throw e;
}
}
/**//// <summary>
/// 返回IDbConnection接口
/// </summary>
/// <returns>IDbConnection接口</returns>
public IDbConnection GetConn()
{
return this.conn;
}
/**//// <summary>
/// 关闭一个数据连接
/// </summary>
public void Close()
{
if (conn.State.ToString().ToUpper() == "OPEN")
{
this.conn.Close();
}
}
/**//// <summary>
/// 用来执行带有参数的SQL语句（不是存储过程）
/// </summary>
/// <param name="SQLText">带有参数的SQL语句</param>
/// <param name="Parameters">传递的参数列表</param>
/// <param name="ParametersValue">同参数列表对应的参数值列表</param>
public void ExecuteNonQuery(string SQLText, string[] Parameters, string[] ParametersValue)
{
this.cmd.CommandText = SQLText;
for (int i = 0; i < Parameters.Length; i++)
{
this.cmd.Parameters.Add("@" + Parameters[i].ToString(), ParametersValue[i].ToString());
}
this.cmd.ExecuteNonQuery();
}
/**//// <summary>
/// 执行存储过程
/// </summary>
/// <param name="StoredProcedureName">存储过程的名称</param>
/// <param name="Parameters">传递的参数列表</param>
/// <param name="ParametersValue">同参数列表对应的参数值列表</param>
/// <param name="ParametersType">同参数列表对应的参数类型列表</param>
public void ExecuteSP(string StoredProcedureName, string[] Parameters, string[] ParametersValue, string[] ParametersType)
{
try
{
this.cmd.CommandText = StoredProcedureName;
this.cmd.CommandType = CommandType.StoredProcedure;
for (int i = 0; i < Parameters.Length; i++)
{
OleDbParameter myParm = this.cmd.Parameters.Add("@" + Parameters[i], Type.GetType(ParametersType[i].ToString()));
myParm.Value = ParametersValue[i];
}
this.cmd.ExecuteNonQuery();
}
catch (Exception e)
{
throw e;
}
}
/**////<summary>
/// 执行存储过程,得到结果集DataSet
/// </summary>
/// <param name="sqname">存储过程名称</param>
/// <param name="array">参数名称与值的数组</param>
/// <returns>返回True或False</returns>
public DataSet ExcuteSp(string sqname, string[,] array)
{
try
{
DataSet dset = new DataSet();
//OleDbDataAdapter dp=new SqlDataAdapter();
//SqlCommand cmmd = new SqlCommand();
OleDbDataAdapter odp = new OleDbDataAdapter();
OleDbCommand ocmd = new OleDbCommand();
odp.SelectCommand = ocmd;
odp.SelectCommand.Connection = this.conn;
odp.SelectCommand.CommandType = CommandType.StoredProcedure;
odp.SelectCommand.CommandText = sqname;
for (int i = 0; i <= array.GetUpperBound(0); i++)
{
if (array[i, 0] != null)
{
//SqlParameter Parm = dp.SelectCommand.Parameters.Add( array[i,0].ToString(), SqlDbType.NVarChar);
OleDbParameter Parm = odp.SelectCommand.Parameters.Add(array[i, 0].ToString(), SqlDbType.NVarChar);
Parm.Value = array[i, 1].ToString();
}
}
odp.Fill(dset, "Default");
return dset;
}
catch (Exception e)
{
throw e;
}
}
public object ExecuteScalar(string QueryString)
{
cmd.CommandText = QueryString;
try
{
return cmd.ExecuteScalar();
}
catch (Exception e)
{
throw e;
}
}
public IDataAdapter getDataAdapter(string sql)
{
return new OleDbDataAdapter(sql, this.conn);
}
public ICommandBuilder getCommandBuilder()
{
return new OleDbCmdBuilder();
}
}
}
对ado.net中各个数据库操作类型的CommandBuilder加一适配
using System.Data;
using System.Data.OleDb;
using System.Data.SqlClient;
namespace MySql.Pantheon.DAO
{
/**//// <summary>
///
/// 对ado.net中各个数据库操作类型的CommandBuilder加一适配
///
/// </summary>
public interface ICommandBuilder
{
/**//// <summary>
/// 设置数据适配器
/// </summary>
/// <param name="da"></param>
void SetDataAdapter(IDataAdapter da);
}
/**//// <summary>
/// sql的命令建造者适配对象
/// </summary>
public class SqlCmdBuilder : ICommandBuilder
{
/**//// <summary>
/// 设置数据适配器
/// </summary>
/// <param name="da">sql数据适配器</param>
public void SetDataAdapter(IDataAdapter da)
{
SqlCommandBuilder cb = new SqlCommandBuilder((SqlDataAdapter) da);
}
}
/**//// <summary>
/// oledb的命令建造者适配对象
/// </summary>
public class OleDbCmdBuilder : ICommandBuilder
{
/**//// <summary>
/// 设置数据适配器
/// </summary>
/// <param name="da">oledb数据适配器</param>
public void SetDataAdapter(IDataAdapter da)
{
OleDbCommandBuilder cb = new OleDbCommandBuilder((OleDbDataAdapter) da);
}
}
}
现在把数据访问层封装起来做为Class ，实现对数据进行访问的数据库操作类
下面是结构组件图
先从一个程序说起，再慢慢深入的理解数据操作类的实现
private void ConnectionDataBase()
{
//连接数据库
CommonInterface pObj_Comm=CommonFactory.CreateInstance(CommonData.sql);
string str_sql="select Guid,ReportID,ReportCompID,ReportFlag,QryConditionID from ReportMain ";
DataTable dt=pObj_Comm.ExeForDtl(str_sql);
pObj_Comm.Close();
MessageBox.Show(dt.Rows.Count.ToString());
}
首先 CommonInterface pObj_Comm=CommonFactory.CreateInstance(CommonData.sql);
调用CommonFactory里面的静态方法 public static CommonInterface CreateInstance(CommonData CommonData_Parameter)
其中 CommonData 是枚举类型
/// <summary>
/// 数据访问类型
/// </summary>
public enum CommonData
{
/// <summary>
/// 以SQL Server方式
/// </summary>
sql = 1,
/// <summary>
/// 以OLEDB方式
/// </summary>
oledb = 2,
} ;
当
case 1:
return new CommonSql();
实例化CommonSql 返回的是CommonInterface 接口类型
CommonInterface 的定义如下：public interface CommonInterface
新建立一个类库 MySql.Pantheon.DAO
1 数据库连接
namespace MySql.Pantheon.DAO
{
/**//// <summary>
/// 作用: 设置数据库默认连接字符串的配置类。
/// 作者:
/// 编写日期:
/// </summary>
public class CommonDataConfig
{
/**//// <summary>
/// 数据库连接字符串
/// </summary>
///<example>使用此静态连接字符串的示例：
/// <code>
/// using MySql.Pantheon.DAO;
/// //设定DAO所要使用的连接参数
/// public static string ConnectionDefaultStrserver=192.168.0.220;database=pantheon;uid=pantheon;pwd=pantheon2002="server=server-test1;database=kmp50;uid=kmp;pwd=123123123";
/// </code>
///</example>
public static string ConnectionDefaultStr = "server=JHTCHINA;database=LGBMISEXT;uid=sa;pwd=jhtchina";
}
}
2 确定访问方式的确定 SQL 方式 还是Oledb方式
using System;
namespace MySql.Pantheon.DAO
{
/**//// <summary>
/// 数据访问类型
/// </summary>
public enum CommonData
{
/**//// <summary>
/// 以SQL Server方式
/// </summary>
sql = 1,
/**//// <summary>
/// 以OLEDB方式
/// </summary>
oledb = 2,
} ;
/**//// <summary>
/// 作用: 数据库访问工厂类
/// 作者:
/// 编写日期:
/// 修改日期：加入代码示例程序
/// </summary>
public class CommonFactory
{
/**//// <summary>
/// 是否单例模式连接
/// </summary>
public static bool IsSingleConnection = false;
/**//// <summary>
/// winForm下的单例模式连接对象 修改:吴炜
/// </summary>
public static CommonInterface SingleConnection;
/**//// <summary>
/// 创建一个数据访问接口,默认返回SQL类型的数据访问接口
/// </summary>
/// <param name="CommonData_Parameter">数据访问类型</param>
/// <returns>CommonInterface接口</returns>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql);
/// </code>
/// </example>
public static CommonInterface CreateInstance(CommonData CommonData_Parameter)
{
switch ((int) CommonData_Parameter)
{
case 1:
return new CommonSql();
case 2:
return new CommonOle();
default:
return new CommonSql();
}
}
/**//// <summary>
/// 创建一个数据访问接口
/// </summary>
/// <param name="CommonData_Parameter">数据访问类型</param>
/// <param name="connstr">数据库的连接串</param>
/// <returns>CommonInterface接口</returns>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// string pConnectionString="";
///
/// pConnectionString="server=192.168.0.220;database=pantheon;uid=pantheon;pwd=pantheon2002";
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
/// </code>
/// </example>
public static CommonInterface CreateInstance(CommonData CommonData_Parameter, String connstr)
{
switch ((int) CommonData_Parameter)
{
case 1:
return new CommonSql(connstr);
case 2:
return new CommonOle(connstr);
default:
return new CommonSql(connstr);
}
}
}
}
3 对数据库通用操作的接口进行定义
using System;
using System.Data;
namespace MySql.Pantheon.DAO
{
/**//// <summary>
/// 作用:对数据库通用操作的接口。
/// 作者:
/// 修改：
/// </summary>
public interface CommonInterface
{
/**//// <summary>
/// 开始一个事务
/// </summary>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// //
/// //进行一些数据访问操作的代码
/// //
///
/// //提交本次的事务
/// pComm.CommitTrans();
///
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
void BeginTrans();
/**//// <summary>
/// 提交一个事务
/// </summary>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// //
/// //进行一些数据访问操作的代码
/// //
///
/// //提交本次的事务
/// pComm.CommitTrans();
///
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
void CommitTrans();
/**//// <summary>
/// 回滚一个事务
/// </summary>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// try
/// {
/// //
/// //进行一些数据访问操作的代码
/// //
///
/// //提交本次的事务
/// pComm.CommitTrans();
///
/// //关闭数据库连结
/// pComm.Close();
/// }
/// catch(Exception ex)
/// {
/// //
/// //自己的处理
/// //
///
/// //回滚此次数据操作
/// pComm.RollbackTrans();
///
/// //关闭数据库连结
/// pComm.Close();
/// }
///
/// </code>
/// </example>
void RollbackTrans();
/**//// <summary>
/// 执行SQL语句
/// </summary>
/// <param name="sql">SQL语句</param>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// //进行一些数据访问操作的代码
/// string pSql="";
///
/// pSql="select * from YourTable";
///
/// //执行此次数据操作
/// pComm.Execute(pSql);
///
/// //提交本次的事务
/// pComm.CommitTrans();
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
void Execute(String sql);
/**//// <summary>
/// 执行SQL语句，填充到指定的DataTable中，返回DataSet
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <param name="strTable">DataTable的名称</param>
/// <returns>DataSet数据集和</returns>
DataSet ExeForDst(String QueryString, String strTable);
/**//// <summary>
/// 执行一段SQL语句，返回DataSet结果集
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <returns>DataSet结果集</returns>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// string pSql="";
/// DataSet pDst=new DataSet();
///
/// //进行一些数据访问操作的代码
/// pSql="select * from YourTable";
///
/// //执行此次数据操作
/// pDst=pComm.ExeForDst(pSql);
///
/// //提交本次的事务
/// pComm.CommitTrans();
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
DataSet ExeForDst(String QueryString);
/**//// <summary>
/// 执行SQL语句，返回DataTable
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <param name="TableName">DataTable的名称</param>
/// <returns>DataTable的结果集</returns>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// string pSql="";
/// DataTable pDst=new DataTable();
///
/// //进行一些数据访问操作的代码
/// pSql="select * from YourTable";
///
/// //执行此次数据操作
/// pDst=pComm.ExeForDtl(pSql,"UserInfo");
///
/// //提交本次的事务
/// pComm.CommitTrans();
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
DataTable ExeForDtl(String QueryString, String TableName);
/**//// <summary>
/// 执行SQL语句，返回默认DataTable
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <returns>DataTable结果集</returns>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// string pSql="";
/// DataTable pDst=new DataTable();
///
/// //进行一些数据访问操作的代码
/// pSql="select * from YourTable";
///
/// //执行此次数据操作
/// pDst=pComm.ExeForDtl(pSql);
///
/// //提交本次的事务
/// pComm.CommitTrans();
///
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
DataTable ExeForDtl(String QueryString);
/**//// <summary>
/// 执行SQL语句，返回IDataReader接口
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <returns>IDataReader接口</returns>
IDataReader ExeForDtr(String QueryString);
/**//// <summary>
/// 返回IDbCommand接口
/// </summary>
/// <returns>IDbCommand接口</returns>
IDbCommand GetCommand();
/**//// <summary>
/// 关闭数据库连接
/// </summary>
void Close();
/**//// <summary>
/// 用来执行带有参数的SQL语句（不是存储过程）
/// </summary>
/// <param name="SQLText">带有参数的SQL语句</param>
/// <param name="Parameters">传递的参数列表</param>
/// <param name="ParametersValue">同参数列表对应的参数值列表</param>
void ExecuteNonQuery(string SQLText, string[] Parameters, string[] ParametersValue);
/**//// <summary>
/// 执行存储过程
/// </summary>
/// <param name="StoredProcedureName">存储过程的名称</param>
/// <param name="Parameters">传递的参数列表</param>
/// <param name="ParametersValue">同参数列表对应的参数值列表</param>
/// <param name="ParametersType">同参数列表对应的参数类型列表</param>
void ExecuteSP(string StoredProcedureName, string[] Parameters, string[] ParametersValue, string[] ParametersType);
/**////<summary>
/// 执行存储过程,得到结果集DataSet
/// </summary>
/// <param name="sqname">存储过程名称</param>
/// <param name="array">参数名称与值的数组</param>
/// <returns>返回True或False</returns>
DataSet ExcuteSp(string sqname, string[,] array);
/**//// <summary>
///
/// </summary>
/// <param name="QueryString"></param>
/// <returns></returns>
object ExecuteScalar(String QueryString);
/**//// <summary>
///
/// </summary>
/// <param name="sql"></param>
/// <returns></returns>
IDataAdapter getDataAdapter(string sql);
/**//// <summary>
///
/// </summary>
/// <returns></returns>
ICommandBuilder getCommandBuilder();
}
}
mssql的数据库连结方式的类 里面有定义实现方式
using System;
using System.Data;
using System.Data.SqlClient;
namespace MySql.Pantheon.DAO
{
/**//// <summary>
/// 作用:mssql的数据库连结方式的类
/// 作者:
/// 编写日期:
/// 修改1：
/// 1、将类声明的修饰符修改为“internal”，防止直接new此类
/// 2、增加对存储过程的封装
///
internal class CommonSql : CommonInterface
{
private SqlConnection conn = null;
private SqlCommand cmd = null;
private SqlTransaction trans = null;
private String connstr = null;
/**//// <summary>
/// 构造方法
/// </summary>
public CommonSql()
{
connstr = CommonDataConfig.ConnectionDefaultStr;
Initial();
}
/**//// <summary>
/// 带有参数的构造方法
/// </summary>
/// <param name="ConnStr_Param">数据库连接字符串</param>
public CommonSql(String ConnStr_Param)
{
connstr = ConnStr_Param;
Initial();
}
/**//// <summary>
/// 初始化
/// </summary>
private void Initial()
{
try
{
if (connstr == null)
{
}
this.conn = new SqlConnection(connstr);
this.cmd = new SqlCommand();
cmd.Connection = this.conn;
this.conn.Open();
}
catch (Exception e)
{
throw e;
}
}
/**//// <summary>
/// 开始一个事务
/// </summary>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// //
/// //进行一些数据访问操作的代码
/// //
///
/// //提交本次的事务
/// pComm.CommitTrans();
///
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
public void BeginTrans()
{
trans = conn.BeginTransaction();
cmd.Transaction = trans;
}
/**//// <summary>
/// 提交一个事务
/// </summary>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// //
/// //进行一些数据访问操作的代码
/// //
///
/// //提交本次的事务
/// pComm.CommitTrans();
///
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
public void CommitTrans()
{
trans.Commit();
}
/**//// <summary>
/// 回滚一个事务
/// </summary>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// try
/// {
/// //
/// //进行一些数据访问操作的代码
/// //
///
/// //提交本次的事务
/// pComm.CommitTrans();
///
/// //关闭数据库连结
/// pComm.Close();
/// }
/// catch(Exception ex)
/// {
/// //
/// //自己的处理
/// //
///
/// //回滚此次数据操作
/// pComm.RollbackTrans();
///
/// //关闭数据库连结
/// pComm.Close();
/// }
///
/// </code>
/// </example>
public void RollbackTrans()
{
trans.Rollback();
}
/**//// <summary>
/// 执行SQL语句
/// </summary>
/// <param name="sql">SQL语句</param>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// //进行一些数据访问操作的代码
/// string pSql="";
///
/// pSql="select * from YourTable";
///
/// //执行此次数据操作
/// pComm.Execute(pSql);
///
/// //提交本次的事务
/// pComm.CommitTrans();
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
public void Execute(String sql)
{
try
{
cmd.CommandText = sql;
cmd.ExecuteNonQuery();
}
catch (Exception e)
{
throw e;
}
}
/**//// <summary>
/// 执行SQL语句，填充到指定的DataTable中，返回DataSet
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <param name="strTable">DataTable的名称</param>
/// <returns>DataSet数据集和</returns>
public DataSet ExeForDst(String QueryString, String strTable)
{
DataSet ds = new DataSet();
SqlDataAdapter ad = new SqlDataAdapter();
cmd.CommandText = QueryString;
修改1#region 修改1
if (QueryString.Length>40000)
{
cmd.CommandTimeout=300;
}
#endregion
try
{
ad.SelectCommand = cmd;
ad.Fill(ds, strTable);
}
catch (Exception e)
{
throw e;
}
return ds;
}
/**//// <summary>
/// 执行一段SQL语句，返回DataSet结果集
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <returns>DataSet结果集</returns>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// string pSql="";
/// DataSet pDst=new DataSet();
///
/// //进行一些数据访问操作的代码
/// pSql="select * from YourTable";
///
/// //执行此次数据操作
/// pDst=pComm.ExeForDst(pSql);
///
/// //提交本次的事务
/// pComm.CommitTrans();
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
public DataSet ExeForDst(String QueryString)
{
DataSet ds = new DataSet();
SqlDataAdapter ad = new SqlDataAdapter();
cmd.CommandText = QueryString;
修改2#region 修改2
if (QueryString.Length>40000)
{
cmd.CommandTimeout=300;
}
#endregion
try
{
ad.SelectCommand = cmd;
ad.Fill(ds);
}
catch (Exception e)
{
throw e;
}
return ds;
}
/**//// <summary>
/// 执行SQL语句，返回DataTable
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <param name="TableName">DataTable的名称</param>
/// <returns>DataTable的结果集</returns>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// string pSql="";
/// DataTable pDst=new DataTable();
///
/// //进行一些数据访问操作的代码
/// pSql="select * from YourTable";
///
/// //执行此次数据操作
/// pDst=pComm.ExeForDtl(pSql,"UserInfo");
///
/// //提交本次的事务
/// pComm.CommitTrans();
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
public DataTable ExeForDtl(String QueryString, String TableName)
{
try
{
DataSet ds;
DataTable dt;
ds = ExeForDst(QueryString, TableName);
dt = ds.Tables[TableName];
ds = null;
return dt;
}
catch
{
throw;
}
finally
{
}
}
/**//// <summary>
/// 执行SQL语句，返回默认DataTable
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <returns>DataTable结果集</returns>
/// <example>示例：
/// <code>
/// using MySql.Pantheon.DAO;
///
/// //创建使用默认数据连接的SQL数据访问接口
/// CommonInterface pComm=CommonFactory.CreateInstance(CommonData.sql,pConnectionString);
///
/// //开始一个事务
/// pComm.BeginTrans();
///
/// string pSql="";
/// DataTable pDst=new DataTable();
///
/// //进行一些数据访问操作的代码
/// pSql="select * from YourTable";
///
/// //执行此次数据操作
/// pDst=pComm.ExeForDtl(pSql);
///
/// //提交本次的事务
/// pComm.CommitTrans();
///
/// //关闭数据库连结
/// pComm.Close();
/// </code>
/// </example>
public DataTable ExeForDtl(String QueryString)
{
try
{
DataSet ds;
DataTable dt;
ds = ExeForDst(QueryString);
dt = ds.Tables[0];
ds = null;
return dt;
}
catch (Exception ee)
{
throw new Exception(ee.Message);
}
finally
{
}
}
/**//// <summary>
/// 执行SQL语句，返回IDataReader接口
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <returns>IDataReader接口</returns>
public IDataReader ExeForDtr(String QueryString)
{
try
{
cmd.CommandText = QueryString;
return cmd.ExecuteReader();
}
catch
{
throw;
}
}
/**//// <summary>
/// 返回IDbCommand接口
/// </summary>
/// <returns>IDbCommand接口</returns>
public IDbCommand GetCommand()
{
try
{
return this.cmd;
}
catch (Exception e)
{
throw e;
}
}
/**//// <summary>
/// 返回IDbConnection接口
/// </summary>
/// <returns>IDbConnection接口</returns>
public IDbConnection GetConn()
{
return this.conn;
}
/**//// <summary>
/// 关闭数据库连接
/// </summary>
public void Close()
{
if (conn.State.ToString().ToUpper() == "OPEN")
{
this.conn.Close();
}
}
/**//// <summary>
/// 用来执行带有参数的SQL语句（不是存储过程）
/// </summary>
/// <param name="SQLText">带有参数的SQL语句</param>
/// <param name="Parameters">传递的参数列表</param>
/// <param name="ParametersValue">同参数列表对应的参数值列表</param>
public void ExecuteNonQuery(string SQLText, string[] Parameters, string[] ParametersValue)
{
try
{
this.cmd.CommandText = SQLText;
for (int i = 0; i < Parameters.Length; i++)
{
this.cmd.Parameters.Add("@" + Parameters[i].ToString(), ParametersValue[i].ToString());
}
this.cmd.ExecuteNonQuery();
}
catch (Exception e)
{
throw e;
}
}
/**//// <summary>
/// 执行存储过程
/// </summary>
/// <param name="StoredProcedureName">存储过程的名称</param>
/// <param name="Parameters">传递的参数列表</param>
/// <param name="ParametersValue">同参数列表对应的参数值列表</param>
/// <param name="ParametersType">同参数列表对应的参数类型列表</param>
public void ExecuteSP(string StoredProcedureName, string[] Parameters, string[] ParametersValue, string[] ParametersType)
{
try
{
this.cmd.CommandText = StoredProcedureName;
this.cmd.CommandType = CommandType.StoredProcedure;
for (int i = 0; i < Parameters.Length; i++)
{
SqlParameter myParm = this.cmd.Parameters.Add("@" + Parameters[i], ParametersType[i].ToString());
myParm.Value = ParametersValue[i];
}
this.cmd.ExecuteNonQuery();
}
catch (Exception e)
{
throw e;
}
}
/**////<summary>
/// 执行存储过程,得到结果集DataSet
/// </summary>
/// <param name="sqname">存储过程名称</param>
/// <param name="array">参数名称与值的数组</param>
/// <returns>返回True或False</returns>
public DataSet ExcuteSp(string sqname, string[,] array)
{
try
{
DataSet dset = new DataSet();
SqlDataAdapter dp = new SqlDataAdapter();
SqlCommand cmmd = new SqlCommand();
dp.SelectCommand = cmmd;
dp.SelectCommand.Connection = this.conn;
dp.SelectCommand.CommandType = CommandType.StoredProcedure;
dp.SelectCommand.CommandText = sqname;
for (int i = 0; i <= array.GetUpperBound(0); i++)
{
if (array[i, 0] != null)
{
SqlParameter Parm = dp.SelectCommand.Parameters.Add(array[i, 0].ToString(), SqlDbType.NVarChar);
Parm.Value = array[i, 1].ToString();
}
}
dp.Fill(dset, "Default");
return dset;
}
catch (Exception e)
{
throw e;
}
}
public object ExecuteScalar(string QueryString)
{
cmd.CommandText = QueryString;
try
{
return cmd.ExecuteScalar();
}
catch (Exception e)
{
throw e;
}
// return null;;
}
public IDataAdapter getDataAdapter(string sql)
{
return new SqlDataAdapter(sql, this.conn);
}
public ICommandBuilder getCommandBuilder()
{
return new SqlCmdBuilder();
}
}
}
OLEDB的数据库连结方式的类 实现对OLEDB的各种操作
using System;
using System.Data;
using System.Data.OleDb;
namespace MySql.Pantheon.DAO
{
/**//// <summary>
/// 作用:OLEDB的数据库连结方式的类
/// 作者:
/// 修改：
/// 编写日期:
/// </summary>
internal class CommonOle : CommonInterface
{
/**//// <summary>
/// 默认的构造方法
/// </summary>
public CommonOle()
{
connstr = CommonDataConfig.ConnectionDefaultStr;
Initial();
}
/**//// <summary>
/// 带有参数的构造方法
/// </summary>
/// <param name="Connstr_Param">数据库连接字符串</param>
public CommonOle(String Connstr_Param)
{
connstr = Connstr_Param;
Initial();
}
/**//// <summary>
/// 初始化
/// </summary>
private void Initial()
{
try
{
if (connstr == null)
{
//throw(new CommonException("连接字符串没有在web.config里设置"));
}
this.conn = new OleDbConnection(connstr);
this.cmd = new OleDbCommand();
cmd.Connection = this.conn;
this.conn.Open();
}
catch (Exception e)
{
throw e;
}
}
private OleDbConnection conn = null;
private OleDbCommand cmd = null;
private OleDbTransaction trans = null;
private String connstr = null;
/**//// <summary>
/// 开始一个事务
/// </summary>
public void BeginTrans()
{
trans = conn.BeginTransaction();
cmd.Transaction = trans;
}
/**//// <summary>
/// 提交一个事务
/// </summary>
public void CommitTrans()
{
trans.Commit();
}
/**//// <summary>
/// 回滚一个事务
/// </summary>
public void RollbackTrans()
{
trans.Rollback();
}
/**//// <summary>
/// 执行一条SQL语句
/// </summary>
/// <param name="sql"></param>
public void Execute(String sql)
{
try
{
cmd.CommandText = sql;
cmd.ExecuteNonQuery();
}
catch (Exception e)
{
throw e;
}
}
/**//// <summary>
/// 执行SQL语句，填充到指定的DataTable中，返回DataSet
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <param name="strTable">DataTable的名称</param>
/// <returns>DataSet数据集和</returns>
public DataSet ExeForDst(String QueryString, String strTable)
{
DataSet ds = new DataSet();
OleDbDataAdapter ad = new OleDbDataAdapter();
cmd.CommandText = QueryString;
try
{
ad.SelectCommand = cmd;
ad.Fill(ds, strTable);
}
catch (Exception e)
{
throw e;
}
return ds;
}
/**//// <summary>
/// 执行一段SQL语句，返回DataSet结果集
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <returns>DataSet结果集</returns>
public DataSet ExeForDst(String QueryString)
{
DataSet ds = new DataSet();
OleDbDataAdapter ad = new OleDbDataAdapter();
cmd.CommandText = QueryString;
try
{
ad.SelectCommand = cmd;
ad.Fill(ds);
}
catch (Exception e)
{
throw e;
}
return ds;
}
/**//// <summary>
/// 执行SQL语句，返回DataTable
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <param name="TableName">DataTable的名称</param>
/// <returns>DataTable的结果集</returns>
public DataTable ExeForDtl(String QueryString, String TableName)
{
try
{
DataSet ds;
DataTable dt;
ds = ExeForDst(QueryString, TableName);
dt = ds.Tables[TableName];
ds = null;
return dt;
}
catch
{
throw;
}
finally
{
}
}
/**//// <summary>
/// 执行SQL语句，返回默认DataTable
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <returns>DataTable结果集</returns>
public DataTable ExeForDtl(String QueryString)
{
try
{
DataSet ds;
DataTable dt;
ds = ExeForDst(QueryString);
dt = ds.Tables[0];
ds = null;
return dt;
}
catch
{
throw;
}
finally
{
}
}
/**//// <summary>
/// 执行SQL语句，返回IDataReader接口
/// </summary>
/// <param name="QueryString">SQL语句</param>
/// <returns>IDataReader接口</returns>
public IDataReader ExeForDtr(String QueryString)
{
try
{
cmd.CommandText = QueryString;
return cmd.ExecuteReader();
}
catch
{
throw;
}
}
/**//// <summary>
/// 返回IDbCommand接口
/// </summary>
/// <returns>IDbCommand接口</returns>
public IDbCommand GetCommand()
{
try
{
return this.cmd;
}
catch (Exception e)
{
throw e;
}
}
/**//// <summary>
/// 返回IDbConnection接口
/// </summary>
/// <returns>IDbConnection接口</returns>
public IDbConnection GetConn()
{
return this.conn;
}
/**//// <summary>
/// 关闭一个数据连接
/// </summary>
public void Close()
{
if (conn.State.ToString().ToUpper() == "OPEN")
{
this.conn.Close();
}
}
/**//// <summary>
/// 用来执行带有参数的SQL语句（不是存储过程）
/// </summary>
/// <param name="SQLText">带有参数的SQL语句</param>
/// <param name="Parameters">传递的参数列表</param>
/// <param name="ParametersValue">同参数列表对应的参数值列表</param>
public void ExecuteNonQuery(string SQLText, string[] Parameters, string[] ParametersValue)
{
this.cmd.CommandText = SQLText;
for (int i = 0; i < Parameters.Length; i++)
{
this.cmd.Parameters.Add("@" + Parameters[i].ToString(), ParametersValue[i].ToString());
}
this.cmd.ExecuteNonQuery();
}
/**//// <summary>
/// 执行存储过程
/// </summary>
/// <param name="StoredProcedureName">存储过程的名称</param>
/// <param name="Parameters">传递的参数列表</param>
/// <param name="ParametersValue">同参数列表对应的参数值列表</param>
/// <param name="ParametersType">同参数列表对应的参数类型列表</param>
public void ExecuteSP(string StoredProcedureName, string[] Parameters, string[] ParametersValue, string[] ParametersType)
{
try
{
this.cmd.CommandText = StoredProcedureName;
this.cmd.CommandType = CommandType.StoredProcedure;
for (int i = 0; i < Parameters.Length; i++)
{
OleDbParameter myParm = this.cmd.Parameters.Add("@" + Parameters[i], Type.GetType(ParametersType[i].ToString()));
myParm.Value = ParametersValue[i];
}
this.cmd.ExecuteNonQuery();
}
catch (Exception e)
{
throw e;
}
}
/**////<summary>
/// 执行存储过程,得到结果集DataSet
/// </summary>
/// <param name="sqname">存储过程名称</param>
/// <param name="array">参数名称与值的数组</param>
/// <returns>返回True或False</returns>
public DataSet ExcuteSp(string sqname, string[,] array)
{
try
{
DataSet dset = new DataSet();
//OleDbDataAdapter dp=new SqlDataAdapter();
//SqlCommand cmmd = new SqlCommand();
OleDbDataAdapter odp = new OleDbDataAdapter();
OleDbCommand ocmd = new OleDbCommand();
odp.SelectCommand = ocmd;
odp.SelectCommand.Connection = this.conn;
odp.SelectCommand.CommandType = CommandType.StoredProcedure;
odp.SelectCommand.CommandText = sqname;
for (int i = 0; i <= array.GetUpperBound(0); i++)
{
if (array[i, 0] != null)
{
//SqlParameter Parm = dp.SelectCommand.Parameters.Add( array[i,0].ToString(), SqlDbType.NVarChar);
OleDbParameter Parm = odp.SelectCommand.Parameters.Add(array[i, 0].ToString(), SqlDbType.NVarChar);
Parm.Value = array[i, 1].ToString();
}
}
odp.Fill(dset, "Default");
return dset;
}
catch (Exception e)
{
throw e;
}
}
public object ExecuteScalar(string QueryString)
{
cmd.CommandText = QueryString;
try
{
return cmd.ExecuteScalar();
}
catch (Exception e)
{
throw e;
}
}
public IDataAdapter getDataAdapter(string sql)
{
return new OleDbDataAdapter(sql, this.conn);
}
public ICommandBuilder getCommandBuilder()
{
return new OleDbCmdBuilder();
}
}
}
对ado.net中各个数据库操作类型的CommandBuilder加一适配
using System.Data;
using System.Data.OleDb;
using System.Data.SqlClient;
namespace MySql.Pantheon.DAO
{
/**//// <summary>
///
/// 对ado.net中各个数据库操作类型的CommandBuilder加一适配
///
/// </summary>
public interface ICommandBuilder
{
/**//// <summary>
/// 设置数据适配器
/// </summary>
/// <param name="da"></param>
void SetDataAdapter(IDataAdapter da);
}
/**//// <summary>
/// sql的命令建造者适配对象
/// </summary>
public class SqlCmdBuilder : ICommandBuilder
{
/**//// <summary>
/// 设置数据适配器
/// </summary>
/// <param name="da">sql数据适配器</param>
public void SetDataAdapter(IDataAdapter da)
{
SqlCommandBuilder cb = new SqlCommandBuilder((SqlDataAdapter) da);
}
}
/**//// <summary>
/// oledb的命令建造者适配对象
/// </summary>
public class OleDbCmdBuilder : ICommandBuilder
{
/**//// <summary>
/// 设置数据适配器
/// </summary>
/// <param name="da">oledb数据适配器</param>
public void SetDataAdapter(IDataAdapter da)
{
OleDbCommandBuilder cb = new OleDbCommandBuilder((OleDbDataAdapter) da);
}
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- .NET 下的数据库操作类库（MyADO）
- .NET 下的数据库操作类库（MyADO）
- ezSQL PHP数据库操作类库
- 使用开源免费类库在.net中操作Excel
- 在.NET中调用DataWindow操作数据库
- iOS关于数据库的操作（使用第三方类库FMDB）
- IOS数据库操作类库MagicalRecord使用说明
- 一起谈.NET技术，关于Windows Phone数据库和Silverlight本地文件操作
- 在.NET中调用DataWindow操作数据库
- 在.NET中调用DataWindow操作数据库
- ECshop对数据库操作进行操作的核心类库
- C# asp.net 操作ACCESS 数据库 类库
- Atitit.操作注册表 树形数据库 注册表的历史 java版本类库总结
- .net中利用数据工厂实现多数据库的操作
- ezSQL PHP数据库操作类库
- 一个数据库操作通用类库
- 一个完整的数据库操作工作类库
- 使用.NET类库操作CSV文件
- .Net新手☞数据库操作
- PHP技巧180220PHP数据库操作类库ezSQL