通用数据库访问类-数据库

Factory设计模式

含义：定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory　Method使一个类的实例化延迟到其子类。我们这里可能会处理对多种数据库的操作，因此，需要首先定义一个操纵数据库的接口，然后，根据数据库的不同，由类工厂决定实例化哪个类。
   下面，我们首先来定义这个访问接口。为了方便说明问题，我们为这个类定义了比较少的方法，其他的方法是很容易参照添加的。同时注意，我这里使用了abstract class来定义这个访问接口，而不是interface，理由在后面可以看到。

定义一个抽象类：
public abstract class DBOperator
   {
   public abstract IDbConnection Connection{get;} //得到数据库连接
   public abstract void Open(); //打开数据库连接
   public abstract void Close(); //关闭数据库连接
   public abstract void BeginTrans(); //开始一个事务
   public abstract void CommitTrans(); //提交一个事务
   public abstract void RollbackTrans(); //回滚一个事务
   public abstract void exeSql(string strSql,string[] strParams,object[] objValues);
   //执行Sql语句，没有返回值
   public abstract DataSet exeSqlForDataSet(string QueryString);
  //执行Sql，返回DataSet
   }
我们编写数据访问的具体实现类:
Sql Server的数据库访问类：  
  internal class SqlDBOperator: DBOperator 
  {   
         private SqlConnection conn;
         //数据库连接
         private SqlTransaction trans;
         //事务处理类   
         private bool inTransaction=false;
         //指示当前是否正处于事务中   
  public override IDbConnection Connection 
    {    　　
     get{
        return this.conn;
        }
    }
   //SQL数据库的连接方法 
  public SqlDBOperator(string strConnection)
    {  
 　　this.conn= new SqlConnection(strConnection); 
    }
　//打开数据连接   
  public override void Open() 
    {   
　　if(conn.State.ToString().ToUpper()!="OPEN")
    this.conn.Open();
    }
　//关闭数据连接 
  public override void Close()  
    {  
 　　if (conn.State.ToString().ToUpper()=="OPEN")
     this.conn.Close();  
    }
　//打开事务处理机制
  public override void BeginTrans()  
    {
   　trans=conn.BeginTransaction() ;  
 　　inTransaction=true;
    }
　//提交事务处理机制 
  public override void CommitTrans()  
    {
   　trans.Commit();  
 　　inTransaction=false; 
    }
　　//回滚事务处理机制  
　 public override void RollbackTrans()
    {  
 　　trans.Rollback();  
 　　inTransaction=false;  
    }
　　//执行SQL语句的操作，无返回值   
 　public override void exeSql(string strSql,string[] strParams,object[] strValues) 
    {    　
　   SqlCommand cmd=new SqlCommand();
   　cmd.Connection=this.conn ;  
 　　if(inTransaction)    　　
　　 cmd.Transaction=trans;    　
　   if((strParams!=null)&&(strParams.Length!=strValues.Length) ) 
     throw new ParamValueNotMatchException("查询参数和值不对应!"); 
     cmd.CommandText=strSql;   
　 　if(strParams!=null)  
       {   
　　    for(int i=0;i<strParams.Length;i++) 
         cmd.Parameters.Add(strParams[i],strValues[i]);
       }  
 　 cmd.ExecuteNonQuery(); 
    }
　//重载执行SQL语句的操作，返回数据集
 　public override DataSet exeSqlForDataSet(string QueryString) 
    {    　
　     SqlCommand cmd=new SqlCommand();
       cmd.Connection=this.conn ; 
  　　 if(inTransaction)    　
       cmd.Transaction=trans;    　
　     DataSet ds = new DataSet();
   　　SqlDataAdapter ad = new SqlDataAdapter();  
 　  　cmd.CommandText=QueryString;  
 　  　ad.SelectCommand =cmd;    　
　     ad.Fill(ds);    　
　     return ds;   
　　}  
}

Oledb的数据库访问类：
internal class OleDBOperator : DBOperator 
 {    
   private OleDbConnection conn; 
   private OleDbTransaction trans; 
   private bool inTransaction=false;
   public OleDBOperator(string strConnection)
   {
   　this.conn= new OleDbConnection(strConnection);
   }
   public override IDbConnection Connection
   {
   　get
        {
         return this.conn;
        }
   }
   public override void Open()
   {
   if(conn.State.ToString().ToUpper()!="OPEN")
   this.conn.Open();
   }
   public override void Close()
   {
   if (conn.State.ToString().ToUpper()=="OPEN")
       this.conn.Close();
   }
   public override void BeginTrans()
   {
   　　trans=conn.BeginTransaction() ;
   　　inTransaction=true;
   }
   public override void CommitTrans()
   {
   　　trans.Commit();
   　　inTransaction=false;
   }
   public override void RollbackTrans()
   {
   　　trans.Rollback();
   　　inTransaction=false;
   }
   public override void exeSql(string strSql,string[] strParams,object[] strValues)
   {   
       OleDbCommand cmd=new OleDbCommand();
  　   cmd.Connection=this.conn ;
       if(inTransaction)
   　　cmd.Transaction=trans;
       if((strParams!=null)&&(strParams.Length!=strValues.Length) )
       throw new ParamValueNotMatchException("查询参数和值不对应!");
       cmd.CommandText=this.ChangeQueryString(strSql);
       if(strParams!=null)
         {
          for(int i=0;i<strParams.Length;i++)
              cmd.Parameters.Add(strParams[i],strValues[i]);
         }
   　　cmd.ExecuteNonQuery();
   }
   public override DataSet exeSqlForDataSet(string QueryString)
   {
   　　OleDbCommand cmd=new OleDbCommand();
       cmd.Connection=this.conn ;
   　　if(inTransaction)
   　　cmd.Transaction=trans;
   　　DataSet ds = new DataSet();
   　　OleDbDataAdapter ad = new OleDbDataAdapter();
       cmd.CommandText=QueryString;
   　　ad.SelectCommand =cmd;
   　　ad.Fill(ds);
   　　return ds;
   　　}
   }

 我们需要创建一个Factory类，来实现自动数据库切换的管理。这个类很简单，主要的功能就是根据数据库连接字符串，判断使用什么数据库，然后，返回适当的数据库操纵类。在这里，判断的方法很简单，只是根据两种数据库连接字符串的不同来判断。在实际中，随着数据库类的增加，判断的方法可能会有所变化。 
 public class DBOperatorFactory
   {
    public static DBOperator GetDBOperator(string strConnection)
     {
  　　if(strConnection.IndexOf("provider=")<0) //SqlServer
        {
  　　return new SqlDBOperator(strConnection);
         }
  　　else //other database
        {
  　　return new OleDBOperator(strConnection);
        }
     } 
   }
客户端在代码调用的时候，可能就是采用如下形式：
   DBOperator db=DBOperatorFactory.GetDBOperator(strConnection)
     db.Open();
     db.需要的操作
     db.Close();
   或者：
   DBOperator db=DBOperatorFactory.GetDBOperator(strConnection)
   db.Open();db.BeginTrans();
   try
   {
   db.需要的操作
   db.CommitTrans();
   }
   catch
   {
    db.RollbackTrans();
   }
  db.Close();

　　当数据库发生变化的时候，DBOperatorFactory会根据数据库连接字符串自动调用相应的类，客户端不会感觉到变化，也不用去关心。这样，实现了良好的封装性。当然，前提是，你在编写程序的时候，没有用到特定数据库的特性，例如，Sql Server的专用函数。
   实际上，Factory模式也可以不使用Factory类来实现，而是让接口抽象类自己来管理，这可以称作自管理的Factory，是Factory模式的一种变形。这么做的好处，是可以免去一个Factory类，使代码更加简练。这么做，我们需要对DBOperator类做一些改变，增加一个Instance方法。这也是对DBOperator采用抽象类而不是接口的原因（接口的方法不能有实现），代码如下： 
  public static DBOperator Instance(string strConnection)
   {   
     if(strConnection.IndexOf("provider=")<0) //SqlServer
       {
          return new SqlDBOperator(strConnection);   
       }
      else //other database
       {
           return new OleDBOperator(strConnection);  
       }
   }
   然后，客户端代码就可能是类似于下面的形式：
   DBOperator db= DBOperator.Instance(strConnection)
   db.Open();
   db.需要的操作 
   db.Close();

 Singleton设计模式
　　含义：保证一个类仅有一个实例，并提供一个访问它的全局访问点。推而广之，当我们需要精确控制类在系统中的实例的个数的时候，就可以使用Singleton模式。现在，我们需要构建一个缓冲池，保存数据库类的实例，正好是Singleton模式发挥作用的时候

我们仍然让DBOperator类自己来管理这个缓冲池，为了实现这个目的，我们需要对DBOperator类做一些变化：  
首先，增加两个变量：
static DBOperator[] ConnectionPool=new DBOperator[int.Parse　ConfigurationSettings.AppSettings["PoolCount"])];

static int CurrentPosition=-1;

然后，对Instance方法做一些改变： 
public static DBOperator Instance(string strConnection)
   {
   if(ApplicationConfiguration.PooledConnectionCount<1) //没有缓冲
   　　{
  　　　 return CreateNewDBOperator(strConnection); 
   　　}
   else
   　　{
  　　　 CurrentPosition++;
  　　　 if(CurrentPosition==ApplicationConfiguration.PooledConnectionCount)
   　　　　　CurrentPosition=0;
   　　　if(ConnectionPool[CurrentPosition]==null)
   　　　　{
　　　　　　 ConnectionPool[CurrentPosition]=CreateNewDBOperator(strConnection);  
　　　　　　}
   　　return ConnectionPool[CurrentPosition];
  　　 } 
　 }
　private static DBOperator CreateNewDBOperator(string strConnection)
   {
   　if(strConnection.IndexOf("provider=")<0) //SqlServer
   　　　{ 
　　　　　 return new SqlDBOperator(strConnection);  
　　　　　}
   　　else //other database
   　　　{
　　　　　return new OleDBOperator(strConnection);  
　　　　　}
   }

以上这些内容不是本人创作，是借见前辈的开发思想整理出来的。本人学得好用，就放在自己的页面上。