.Net 下数据库操作类库

最新推荐文章于 2024-04-09 15:02:40 发布
最新推荐文章于 2024-04-09 15:02:40 发布
阅读量1.3k 收藏
点赞数
分类专栏： ASP.NET 文章标签： 数据库 .net parameters sql string 存储
现在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


            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

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

}
asp.net数据库操作类
12-08
asp.net数据库操作类
.NET通用的数据库操作类(支持多种数据库)
记得微笑的专栏
05-13 8898
通用的数据库操作类(支持多种数据库)       我们在软件开发过程中,数据库是一个永久不变的话题,但是根据软件架构与客户要求的不同我们会选择不同的数据库,在C#中不同数据库操作编写代码不尽相同,下面提供一种通用的数据库操作方案,只需要根据config的配置就可以动态的选择不同的数据库. 在配置文件中providerName指定不同的数据库类型.           
.net 数据库操作技术
qq_24769781的博客
05-22 337
现代应用开发的经验，都要求尽量保持数据库的干净，避免使用存储过程、外键、视图等，这些功能都应该在程序端来实现，所以推荐使用Dapper。2、由于EFCore，增加了LINQ至SQL的翻译步骤，如果复杂一些的LINQ语句，机翻的结果可能不是最优的SQL语句，同时，EFCore会对实体类状态进行跟踪，所以性能会稍低于Dapper。5、EF Core是官方推荐、推进的框架，尽量屏蔽底层数据库差异，.NET开发者必须熟悉，根据的项目情况再决定用哪个。.net 常用的orm:EF，EF core、Dapper、
使用ADO.NET技术访问数据库——数据库操作类
weixin_44498188的博客
04-26 3915
ADO.NET技术是数据库访问的一个重要方法。 它常用的五个对象分别是：1.Connection2.Command3.DatadAdapter4.DataSet5.DataReader 1.Connection：就是连接数据库 2.Command：执行（T-SQL语句），就是数据库的命令 3.DataAdapter：负责数据库和数据集之间的一个联系，相当于桥梁 4.DataSet：用户填充dataset，断开的模式下进行 5.DataReader：负责从数据源中读取数据 visual stud
mysql 操作类 C .net_.NET MYSQL数据库操作基类( C#源码)
weixin_36098968的博客
01-18 290
使用MySql.Data.dll，它.Net访问MySQL数据库的一个驱动　　下载DbHelperMySql.CSusing System;using System.Collections;using System.Collections.Specialized;using System.Data;using System.Data.SqlClient;using System.Configura...
.net 数据库操作类库
11-07
.NET 数据库操作类库是一种用于简化数据库交互的软件组件，主要目标是为开发者提供一个统一的接口，以便在多种数据库管理系统（如MySQL、SQL Server、Oracle等）中进行数据操作。这种类库通常包含了诸如连接数据库、...
.Net2.0数据库操作类库
01-07
.Net2.0数据库操作类库 支持SQL200,SQL2005,Access,Excel 使用反射编写 一般操作不用写SQL语句
封装好的.net连接各种数据库的类库
06-02
在.NET开发环境中，数据库连接和操作是不可或缺的部分。这个封装好的类库为开发者提供了一站式的解决方案，使得与各种数据库的交互变得更加简单和高效。标题中的"封装好的.net连接各种数据库的类库"指的是一个已经...
.net汉字转拼音类库dll
最新发布
11-04
.net汉字转拼音类库dll作为开发者工具箱中的重要一员，极大地方便了.NET平台下汉字信息的处理。通过NPinyin.dll这类类库的使用，开发者能够更加专注于业务逻辑的实现，而不必担心底层复杂的技术实现问题。这类工具的...
VC.NET使用.Net类库访问数据库
03-15
本文将深入探讨如何利用.NET类库在VC.NET中进行数据库操作。 首先，我们要了解.NET Framework中的ADO.NET（ActiveX Data Objects .NET），这是一个数据访问模型，用于连接、查询和管理各种类型的数据库。ADO.NET的...
自己封装的.net 通用数据库操作类 方法很全， 支持存储过程，参数！
06-04
自己封装的.net 通用数据库操作类 方法很全， 支持存储过程，参数！ 呵呵大家拿去用吧！适合新人
ASP.NET通用数据库操作类DBHelper
10-08
通用的DBHelper类，接口式编程，适用于任何数据库
C#.Net底层操作数据库及常用功能封装类
09-14
常用数据库操作功能的封装。 消息功能封装 常用加密解密方式的封装 邮件发送功能的封装 数据字符串功能的封装 等等
vb.net 封装数据库操作类（自用）
as495916的博客
12-18 741
封装数据库操作，vb.net
C#.NET操作数据库通用类（MS SQL Server篇）
04-13 3502
下面给出了一个C#操作MS SQL Server 数据库的通用类，通过该类可以对数据库进行任何操作，包括执行SQL语句、执行存储过程。以下是其详细实现过程，希望大家共同修改优化之。稍后将介绍如何使用它实现N层的程序设计。 配置web.config文件的链接参数       connStr参数设置，事例说明：  （1）Sql server数据库，例如“server=local;dat
基于.NET平台的Windows编程实战（四）—— 数据库操作类的编写
Asidy'blog - csdn
06-03 627
大家都知道本系统的正常运行少不了数据库操作这一块，且其在本系统中具有决定性作用，可以说没有它的操作系统将无法运行，故在本节课程中，专门把针对数据库的操作类拿出来讲讲，以便大家更加容易理解后面的课程。好，进入正题……首先，我们来新建一个类，方法如下：打开上一节课我们新建的QuestionnaireSystem项目，右击项目名，在出现的对话框中选择“添加”à“类”，在弹出的“添加新项”中选
数据库操作类（ASP.NET）
大班的专栏
10-17 843
 using System;   using System.Data.SqlClient;  using System.Data;  using System.Configuration;   namespace web.base_class   {       ///       /// db_class 的摘要说明。注意用到executereader后一定要调
使用ADO.NET访问数据库
m0_62263513的博客
04-09 2596
使用ADO.NET访问数据库
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值