深水池塘

升级我的数据库辅助类(提供下载)

petshop通过抽象工厂实现了数据库的自由切换，但是我不喜欢这种方式。一是需要多建好几个项目，每一个数据库都要一个DAL和Help类。项目多了，代码量自然也多了，维护起来不方便，修改一个东西要改动好几个地方。

它是在DAL层面实现的数据库切换，几个Help没有什么联系，而且代码大量重复。为什么不在Help类里实现数据库里切换呢~这样只需要一个DAL，在配置文件里改一下，Help类就会返回不同数据库的对象供DAL使用。怎么实现呢，我想到了两种方式。

第一个自然是反射，使用System.Data.Common命名空间的类，代码如下：

Code
using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.Data;
using System.Data.Common;
using System.Collections;

namespace Jdpc.DBHelper
{
/// <summary>
/// 数据库的通用访问代码
/// 此类为静态类，不允许实例化，在应用时直接调用即可
/// </summary>
public static class Datahelper
{

private static string assemblyname =DBConfig.AssemblyName;
private static string namespacename = DBConfig.NameSpace;
private static string connectionname = DBConfig.ConnectionName;
private static string dataadaptername = DBConfig.DataAdapterName;

//获取数据库连接字符串，其属于静态变量且只读，项目中所有文档可以直接使用，但不能修改
public static readonly string ConnectionStringLocalTransaction = DBConfig.ConnectString;


/// <summary>
///执行一个不需要返回值的SqlCommand命令，通过指定专用的连接字符串。
/// 使用参数数组形式提供参数列表
/// </summary>
/// <remarks>
/// 使用示例：
/// int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="connectionString">一个有效的数据库连接字符串</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
public static int ExecuteNonQuery(string connectionString, CommandType cmdType, string cmdText, params DbParameter[] commandParameters)
{



using (DbConnection conn=(DbConnection)Assembly.Load(assemblyname).CreateInstance(namespacename + "." +connectionname))
{
DbCommand cmd = conn.CreateCommand();
conn.ConnectionString = connectionString;
//通过PrePareCommand方法将参数逐个加入到SqlCommand的参数集合中
PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
int val = cmd.ExecuteNonQuery();

//清空SqlCommand中的参数列表
cmd.Parameters.Clear();
return val;
}
}
/// <summary>
/// 执行一个不需要返回值的SqlCommand命令,默认使用SQL语句
/// </summary>
/// <param name="cmdText"> T-SQL语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
public static int ExecuteNonQuery(string cmdText, params DbParameter[] commandParameters)
{
return ExecuteNonQuery(ConnectionStringLocalTransaction, CommandType.Text, cmdText, commandParameters);
}
/// <summary>
/// 执行一个不需要返回值的SqlCommand命令,不带任何参数
/// </summary>
/// <param name="cmdText">T-SQL语句</param>
/// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
public static int ExecuteNonQuery(string cmdText)
{
return ExecuteNonQuery(ConnectionStringLocalTransaction, CommandType.Text, cmdText, null);
}
/// <summary>
///执行一条不返回结果的SqlCommand，通过一个已经存在的数据库连接
/// 使用参数数组提供参数
/// </summary>
/// <remarks>
/// 使用示例：
/// int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="conn">一个现有的数据库连接</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
public static int ExecuteNonQuery(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] commandParameters)
{

DbCommand cmd = connection.CreateCommand();

PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
int val = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
return val;
}

/// <summary>
/// 执行一条不返回结果的SqlCommand，通过一个已经存在的数据库事物处理
/// 使用参数数组提供参数
/// </summary>
/// <remarks>
/// 使用示例：
/// int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="trans">一个存在的 sql 事物处理</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
public static int ExecuteNonQuery(DbTransaction trans, CommandType cmdType, string cmdText, params DbParameter[] commandParameters)
{
DbCommand cmd = trans.Connection.CreateCommand();
PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, commandParameters);
int val = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
return val;
}

/// <summary>
/// 执行多条SQL语句，实现数据库事务。
/// </summary>
/// <param name="SQLStringList">多条SQL语句</param>
public static void ExecuteSqlTran(string connectionString, List<string> SQLStringList)
{
using (DbConnection conn = (DbConnection)Assembly.Load(assemblyname).CreateInstance(namespacename + "." + connectionname))
{
conn.ConnectionString = connectionString;
conn.Open();
DbCommand cmd = conn.CreateCommand();
DbTransaction tx = conn.BeginTransaction();
cmd.Transaction = tx;
try
{
for (int n = 0; n < SQLStringList.Count; n++)
{
string strsql = SQLStringList[n].ToString();
if (strsql.Trim().Length > 1)
{
cmd.CommandText = strsql;
cmd.ExecuteNonQuery();
}
}
tx.Commit();
}
catch (System.Data.Common.DbException E)
{
tx.Rollback();
throw new Exception(E.Message);
}
}
}
public static void ExecuteSqlTran(List<string> SQLStringList)
{
ExecuteSqlTran(ConnectionStringLocalTransaction, SQLStringList);
}

/// <summary>
/// 执行一条返回结果集的SqlCommand命令，通过专用的连接字符串。
/// 使用参数数组提供参数
/// </summary>
/// <remarks>
/// 使用示例：
/// SqlDataReader r = ExecuteReader(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="connectionString">一个有效的数据库连接字符串</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个包含结果的SqlDataReader</returns>
public static DbDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText, params DbParameter[] commandParameters)
{

DbConnection conn = (DbConnection)Assembly.Load(assemblyname).CreateInstance(assemblyname+ "." + connectionname);
conn.ConnectionString = connectionString;
DbCommand cmd = conn.CreateCommand();
// 在这里使用try/catch处理是因为如果方法出现异常，则SqlDataReader就不存在，
//CommandBehavior.CloseConnection的语句就不会执行，触发的异常由catch捕获。
//关闭数据库连接，并通过throw再次引发捕捉到的异常。
try
{
PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
DbDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
cmd.Parameters.Clear();
return rdr;
}
catch
{
conn.Close();
throw;
}
}
/// <summary>
/// 执行一条返回结果集的SqlCommand命令，默认使用SQL语句
/// </summary>
/// <param name="cmdText">T-SQL语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个包含结果的SqlDataReader</returns>
public static DbDataReader ExecuteReader(string cmdText, params DbParameter[] commandParameters)
{
return ExecuteReader(ConnectionStringLocalTransaction, CommandType.Text, cmdText, commandParameters);
}
/// <summary>
/// 执行一条返回结果集的SqlCommand命令,不使用任何参数
/// </summary>
/// <param name="cmdText">T-SQL语句</param>
/// <returns>返回一个包含结果的SqlDataReader</returns>
public static DbDataReader ExecuteReader(string cmdText)
{
return ExecuteReader(ConnectionStringLocalTransaction, CommandType.Text, cmdText, null);
}
/// <summary>
/// 执行一条返回第一条记录第一列的SqlCommand命令，通过专用的连接字符串。
/// 使用参数数组提供参数
/// </summary>
/// <remarks>
/// 使用示例：
/// Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="connectionString">一个有效的数据库连接字符串</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个object类型的数据，可以通过 Convert.To{Type}方法转换类型</returns>
public static Jobject ExecuteScalar(string connectionString, CommandType cmdType, string cmdText, params DbParameter[] commandParameters)
{

using (DbConnection connection = (DbConnection)Assembly.Load(assemblyname).CreateInstance(namespacename + "." + connectionname))
{
connection.ConnectionString = connectionString;
DbCommand cmd = connection.CreateCommand();
PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
Jobject val = new Jobject(cmd.ExecuteScalar());
cmd.Parameters.Clear();
return val;
}
}
/// <summary>
/// 执行一条返回第一条记录第一列的SqlCommand命令，默认使用SQL语句
/// </summary>
/// <param name="cmdText">T-SQL语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个object类型的数据，可以通过 Convert.To{Type}方法转换类型</returns>
public static Jobject ExecuteScalar(string cmdText, params DbParameter[] commandParameters)
{
return ExecuteScalar(ConnectionStringLocalTransaction, CommandType.Text, cmdText, commandParameters);
}
/// <summary>
/// 执行一条返回第一条记录第一列的SqlCommand命令,不使用参数
/// </summary>
/// <param name="cmdText">T-SQL语句</param>
/// <returns>返回一个object类型的数据，可以通过 Convert.To{Type}方法转换类型</returns>
public static Jobject ExecuteScalar(string cmdText)
{
return ExecuteScalar(ConnectionStringLocalTransaction, CommandType.Text, cmdText, null);
}
/// <summary>
/// 执行一条返回第一条记录第一列的SqlCommand命令，通过已经存在的数据库连接。
/// 使用参数数组提供参数
/// </summary>
/// <remarks>
/// 使用示例：
/// Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="conn">一个已经存在的数据库连接</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个object类型的数据，可以通过 Convert.To{Type}方法转换类型</returns>
public static Jobject ExecuteScalar(DbConnection connection, CommandType cmdType, string cmdText, params DbParameter[] commandParameters)
{

DbCommand cmd = connection.CreateCommand();

PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
Jobject val = new Jobject(cmd.ExecuteScalar());
cmd.Parameters.Clear();
return val;
}
/// <summary>
/// 执行查询语句，返回DataSet
/// </summary>
/// <param name="connectionString">连接字符串</param>
/// <param name="SQLString">查询语句</param>
/// <returns>DataSet</returns>
public static DataSet ExecuteDataSet(string connectionString, string SQLString)
{
if (SQLString != null && SQLString.Trim() != "")
{
using (DbConnection connection = (DbConnection)Assembly.Load(assemblyname).CreateInstance(namespacename + "." + connectionname))
{
connection.ConnectionString = connectionString;
DataSet ds = new DataSet();
try
{
connection.Open();
DbDataAdapter adapter = (DbDataAdapter)Assembly.Load(assemblyname).CreateInstance(namespacename + "." + dataadaptername);
DbCommand cmd = connection.CreateCommand();
cmd.CommandText=SQLString;
adapter.SelectCommand = cmd;
adapter.Fill(ds, "ds");
}
catch (System.Data.Common.DbException ex)
{
throw new Exception(ex.Message);
}
return ds;
}
}
else
{
return null;
}
}
/// <summary>
/// 执行查询语句，返回DataSet，省略查询字符串
/// </summary>
/// <param name="SQLString">查询语句</param>
/// <returns>DataSet</returns>
public static DataSet ExecuteDataSet(string SQLString)
{
return ExecuteDataSet(ConnectionStringLocalTransaction, SQLString);
}


/// <summary>
/// 为执行命令准备参数
/// </summary>
/// <param name="cmd">SqlCommand 命令</param>
/// <param name="conn">已经存在的数据库连接</param>
/// <param name="trans">数据库事物处理</param>
/// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
/// <param name="cmdText">Command text，T-SQL语句 例如 Select * from Products</param>
/// <param name="cmdParms">返回带参数的命令</param>
private static void PrepareCommand(DbCommand cmd, DbConnection conn, DbTransaction trans, CommandType cmdType, string cmdText, DbParameter[] cmdParms)
{

//判断数据库连接状态
if (conn.State != ConnectionState.Open)
conn.Open();
if(cmd.Connection!=null)
cmd.Connection = conn;
cmd.CommandText = cmdText;

//判断是否需要事物处理
if (trans != null)
cmd.Transaction = trans;

cmd.CommandType = cmdType;

if (cmdParms != null)
{
foreach (DbParameter parm in cmdParms)
cmd.Parameters.Add(parm);
}
}
}
}

比较不好处理的是DbParameter，程序里用的是DbParameter数组，自然可以接受SqlParameter或OleDbParameter数组，可以像Petshop那样在外部构建一个SqlParameter数组传进来就行了。但是这样客户端就必须知道具体数据库的类型，没有达到封装的目的。我见yueue.ADOKeycap的处理方式不错，但是我的全是静态方法，不能这么搞，于是想了一个笨方法。做了一个类。

Code
using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.Data;
using System.Data.Common;
using System.Collections;

namespace Jdpc.DBHelper
{
public class JDParameter//:DbParameter
{
#region 字段

private static string assemblyname = DBConfig.AssemblyName;
private static string namespacename = DBConfig.NameSpace;
private static string connectionname = DBConfig.ConnectionName;
private static DbCommand cmd = ((DbConnection)Assembly.Load(assemblyname).CreateInstance(namespacename + "." + connectionname)).CreateCommand();
private static DbParameter dbparam =cmd.CreateParameter();
private List<DbParameter> dbparams = new List<DbParameter>();
#endregion 字段

#region 索引器
public DbParameter this[int index]
{
get
{
return dbparams[index];
}
set
{
dbparams[index] = value;
}
}
public DbParameter this[string pname]
{
get
{
for (int i = 0; i < dbparams.Count; i++)
{
if (dbparams[i].ParameterName == pname)
return dbparams[i];
}
return null;
}
set
{
for (int i = 0; i < dbparams.Count; i++)
{
if (dbparams[i].ParameterName == pname)
dbparams[i] = value;
return;
}
throw new Exception("未找到。");
}
}
#endregion 索引器

#region 增加
/// <summary>
/// 设置参数各项并增加到参数列表
/// </summary>
/// <param name="pname">获取或设置 JDParameter 的名称</param>
/// <param name="dtype">获取或设置参数的 DbType</param>
/// <param name="size">获取或设置列中数据的最大大小（以字节为单位）</param>
/// <param name="value">获取或设置该参数的值。</param>
public void Add(string pname, DbType dtype, int size, object value)
{
DbParameter dparam = cmd.CreateParameter();
dparam.ParameterName = pname;
dparam.DbType = dtype;
dparam.Size = size;
dparam.Value = value;
dbparams.Add(dparam);
}
/// <summary>
/// 设置参数各项并增加到参数列表
/// </summary>
/// <param name="pname">获取或设置 JDParameter 的名称</param>
/// <param name="dtype">获取或设置参数的 DbType</param>
/// <param name="size">获取或设置列中数据的最大大小（以字节为单位）</param>
public void Add(string pname, DbType dtype, int size)
{
DbParameter dparam = cmd.CreateParameter();
dparam.ParameterName = pname;
dparam.DbType = dtype;
dparam.Size = size;
dbparams.Add(dparam);
}
/// <summary>
/// 设置参数各项并增加到参数列表
/// </summary>
/// <param name="pname">获取或设置 JDParameter 的名称</param>
/// <param name="dtype">获取或设置参数的 DbType</param>
public void Add(string pname, DbType dtype)
{
DbParameter dparam = cmd.CreateParameter();
dparam.ParameterName = pname;
dparam.DbType = dtype;
dbparams.Add(dparam);
}
/// <summary>
/// 把一个DbParameter增加到参数列表
/// </summary>
/// <param name="dparam">一个DbParameter对象</dparam>
public void Add(DbParameter dparam)
{
dbparams.Add(dparam);
}

/// <summary>
/// 把一个默认的DbParameter增加到参数列表
/// </summary>
/// <param name="dparam">一个DbParameter对象</dparam>
public void Add()
{
dbparams.Add(dbparam);
}
#endregion 增加

#region 插入
/// <summary>
/// 设置参数各项并增加到参数列表指定位置
/// </summary>
/// <param name="index">指定的位置</param>
/// <param name="pname">获取或设置 JDParameter 的名称</param>
/// <param name="dtype">获取或设置参数的 DbType</param>
/// <param name="size">获取或设置列中数据的最大大小（以字节为单位）</param>
/// <param name="value">获取或设置该参数的值。</param>
public void Insert(int index, string pname, DbType dtype, int size, object value)
{
DbParameter dparam = cmd.CreateParameter();
dparam.ParameterName = pname;
dparam.DbType = dtype;
dparam.Size = size;
dparam.Value = value;
dbparams.Insert(index, dparam);
}
/// <summary>
/// 设置参数各项并增加到参数列表指定位置
/// </summary>
/// <param name="index">指定的位置</param>
/// <param name="pname">获取或设置 JDParameter 的名称</param>
/// <param name="dtype">获取或设置参数的 DbType</param>
/// <param name="size">获取或设置列中数据的最大大小（以字节为单位）</param>
public void Insert(int index, string pname, DbType dtype, int size)
{
DbParameter dparam = cmd.CreateParameter();
dparam.ParameterName = pname;
dparam.DbType = dtype;
dparam.Size = size;
dbparams.Insert(index, dparam);
}
/// <summary>
/// 设置参数各项并增加到参数列表指定位置
/// </summary>
/// <param name="index">指定的位置</param>
/// <param name="pname">获取或设置 JDParameter 的名称</param>
/// <param name="dtype">获取或设置参数的 DbType</param>
public void Insert(int index, string pname, DbType dtype)
{
DbParameter dparam = cmd.CreateParameter();
dparam.ParameterName = pname;
dparam.DbType = dtype;
dbparams.Insert(index, dparam);
}
/// <summary>
/// 把一个DbParameter增加到参数列表指定位置
/// </summary>
/// <param name="index">指定的位置</param>
/// <param name="dparam">一个DbParameter对象</dparam>
public void Insert(int index, DbParameter dparam)
{
dbparams.Insert(index,dparam);
}

/// <summary>
/// 把默认的DbParameter增加到参数列表指定位置
/// </summary>
/// <param name="index">指定的位置</param>
public void Insert(int index)
{
dbparams.Insert(index,dbparam);
}
#endregion 插入

#region 删除
/// <summary>
/// 删除ParameterName为pname的项
/// </summary>
/// <param name="pname">ParameterName属性</param>
public void Remove(string pname)
{
for(int i=0;i<dbparams.Count;i++)
{
if(dbparams[i].ParameterName==pname)
{
dbparams.RemoveAt(i);
}
}
}
/// <summary>
/// 删除指定的DbParameter
/// </summary>
/// <param name="dbp">欲删除的项</param>
public void Remove(DbParameter dbp)
{
dbparams.Remove(dbp);
}
/// <summary>
/// 删除指定位置的项
/// </summary>
/// <param name="index">项的位置</param>
public void RemoveAt(int index)
{
dbparams.RemoveAt(index);
}

/// <summary>
/// 删除从index开始共count个元素
/// </summary>
/// <param name="index">开始位置</param>
/// <param name="count">删除个数</param>
public void RemoveRange(int index, int count)
{
dbparams.RemoveRange(index,count);
}
/// <summary>
/// 全部删除
/// </summary>
public void Clear()
{
dbparams.Clear();
}
#endregion 删除

#region 属性

/// <summary>
/// 获得参数列表
/// </summary>
public DbParameter[] Dbparams
{
get
{
return dbparams.ToArray();
}
}

/// <summary>
/// 获取或设置参数的 DbType。
/// </summary>
public DbType DbType
{
get
{
return dbparam.DbType;
}
set
{
dbparam.DbType = value;
}
}

/// <summary>
/// 获取或设置该参数的值。
/// </summary>
public object Value
{
get
{
return dbparam.Value;
}
set
{
dbparam.Value = value;
}
}

/// <summary>
/// 获取或设置 JDParameter 的名称。
/// </summary>
public string ParameterName
{
get
{
return dbparam.ParameterName;
}
set
{
dbparam.ParameterName = value;
}
}

/// <summary>
/// 获取或设置列中数据的最大大小（以字节为单位）。
/// </summary>
public int Size
{
get
{
return dbparam.Size;
}
set
{
dbparam.Size = value;
}
}
#endregion 属性

}
}

这样就可以像这样调用了。

Code
JDParameter jdp = new JDParameter();
jdp.Add("@UserID", DbType.String, 50);
jdp.Add("@UserKey", DbType.String, 50);

jdp[0].Value = Server.HtmlEncode(txtsmsUID.Text.Trim());
jdp[1].Value = Server.HtmlEncode(txtsmsPWD.Text.Trim());
DbDataReader read = JDBHelper.Datahelper.ExecuteReader("select * from UserTable where UserID=@UserID and UserKey=@UserKey"

这样改造之后应该就可以实现自由切换数据库了。只需修改一下配置文件就Ok。但是我却有点不安，因为在静态方法里使用了反射，每次调用都要反射一次（为了行文方便，这种方法我暂且称之为静态反射），会不会降低性能呢~

于是想到了另一个方法，使用策略模式。先写一个Help的abstract类：

Code
using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Data.Common;
using System.Collections.Generic;

namespace Jdpc.DBHelper
{
/// <summary>
/// 数据库的通用访问类的父类
/// </summary>
public abstract class DBStrategy
{
//获取数据库连接字符串，其属于静态变量且只读，项目中所有文档可以直接使用，但不能修改
public readonly string ConnectionStringLocalTransaction = DBConfig.ConnectString;

// 哈希表用来存储缓存的参数信息，哈希表可以存储任意类型的参数。
private Hashtable parmCache = Hashtable.Synchronized(new Hashtable());

protected abstract DbParameter GetParameterType();
internal DbParameter GetDbParameter(string pname, DbType dtype, int size, object value)
{
DbParameter par = GetParameterType();
par.ParameterName = pname;
par.DbType = dtype;
par.Size = size;
par.Value = value;
return par;
}
internal DbParameter GetDbParameter(string pname, DbType dtype, int size)
{
DbParameter par = GetParameterType();
par.ParameterName = pname;
par.DbType = dtype;
par.Size = size;
return par;
}
/// <summary>
///执行一个不需要返回值的DbCommand命令，通过指定专用的连接字符串。
/// 使用参数数组形式