.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


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

    }


}



具体的调用操作Class 将在下篇文章中做出分析
posted @ 2005-09-28 00:00 jhtchina 阅读(...) 评论(...)  编辑 收藏

公告

http://count.51yes.com/