.Net 下数据库操作类库 一点学习和研究 实现类

 现在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 将在下篇文章中做出分析