告别ADO.NET实现应用系统无缝切换的烦恼(总结篇)

可能只是那么想也是那么设计的，要支持多数据库，要能支持多数据库，万一要是以后数据库变了怎么办？万一要是。。。怎么办？这些顾虑很多时候是不必要的，反而绕了弯子。大都是做项目应用系统而非产品，即使要用不同的数据库了，基本上是吧上一个项目全copy过来，修修改改ok了。产品可能就不一样了，那才可能要支持真正的多数据库，才可能会面对真正的数据库访问类库的多数据库的实际检验。ado.net2.0下增强了数据库访问的功能，也就是工厂式类库，提到工厂式数据库访问，网上可就多了，ado.net2.0增强的工厂式网上也很多了，都说只要改动webconfig里的数据库连接就行了，其它什么地方都不用改了，看了几篇都是点了下，不知道做过充分测试没有，应该说在实际的多数据库产品系统中，还要做很多修正，完善和测试的。
说正题，假设（只是假设，真的不会这么变态，呵呵）一产品系统要支持access,sybase,sql server,oracel数据库，系统开发完后，要求只改动数据库的连接，也就是说只改动webconfig，来实现系统的无缝切换，其它什么也不改动，可能有的觉得简单，但是要经得起实际检验还是要花点时间测试的，当然写是不算难，见到过有的应用系统开发中，所有的dml语句都以xml形式放在config配置文件里，然后用封装好的数据库访问组件读config配置文件执行sql语句，开发人员只要建个config文件把增删改查语句写那里就可以，当然这么来有个好处，就是做到了与数据库的无关性了，如果数据库访问组件做的完善的，当然是可以做到系统无缝切换到其它数据库的，当然同时也有缺陷，项目中不仅仅是dml语句吧，有的稍微复杂点的逻辑，存储过程要用下吧，我自己也趋向于喜欢用存储过程，自定义函数来处理稍微复杂的逻辑，而且把dml语句都放在配置文件里我也是不能忍受的，可能是一个个人的习惯吧。
继续，下面开始我要说的利用ado.net2.0及以上版本新增的工厂式数据库访问实现应该系统的无缝切换，要实现无缝切换，当然还是要有前提条件了，就是各个不同的数据库之间的表和其它对象都已经成功移植了，没有这个前提，纯用ado.net做系统无缝切换那是不可能的了，比如sql server中写的存储过程，自定义函数直接复制到oracle上就行了吗？当然是不行，写法及变量定义要做些调整才可以成功移植的，还有变结构字段类型等等的都可能是要做相应调整，这些都做好了才能谈系统的无缝切换。要做的无缝切换，数据库访问层的代码中最好（并非绝对）不应该出现sqlcommand，sqldataadapter,sqlclient,sqlxxx吧，要切换到oracle数据上，甲骨文会把你的sqlxxx玩死的，oracle里可以oraclecommand，oraclexxx，还有程序执行带参数语句时，比如 where userid=@userid，甲骨文也会玩死你的，oracle里可是where userid=:userid，@前缀在access,sybase,sql server里是都认得，还有还有字段名的写法问题，oracle里可以区分大小写的，比如可能大多习惯这样命名属性和自段,username,userage，如果在oracle里这么命名的话，系统开发过程中的那种痛苦也许只有经历过的人才知道，oracle坚持大写为标准，记得很久很久以前的一个夏天的晚上，那时我还是年轻的80后，一位数据库设计比较n的人提到过，尽量在数据库设计和t-sql编程中采用大写标准，基本上接触的sql server数据库较多，也习惯了表名，字段名的大写设计，后来发现确实是有道理的。这里提到的问题都是在下面的各个方法中为了兼容不同的数据库需要面对的问题，具体讲到每个执行方法时再具体解释。刚才说sqlcommand,oraclecomand都是各自认得，但是dbcommand可是大家都认得的，暂且叫抽象对象吧，还有dbconnection，dbdataadapter等都是他们都认得的，所以在做支持多数据库访问类库时，就可以用这些对象了，根据这些对象再创建具体对象。ado.net2.0中数据库访问工厂中有个 dbproviderfactory 对象，也就是通常说的dataprovider了，正是这个起了关键和方便的作用，是用来创建提供程序对数据源类的实现的实例（就是用来创建实例）。另外数据库操作还要用到参数吧，dbparameter，dbparametercollection下面都需要用到，先贴一段类库的构造函数，因为共用对象需要先实例化。

public dbconnection conn;//抽象类型
private dbcommand cmd;//抽象类型
private dbproviderfactory provider;
private dbparameter para;//不同数据库参数类型的抽象类型
private dbdataadapter adapter;//对应不同数据库的数据适配器
dictionary<type, string> parametersformat;//不同数据库参数格式化类型
public string retparaformat = string.empty;//最终返回的格式化标志，如@{0},:{0}
public dataproviderfactory()
{
//从配置文件中取出标示数据库类型的字符串并通过providername的不同支持不同类型的数据库
string providername = configurationmanager.connectionstrings["connstr"].providername;//也可以用索引,从1开始
//创建一个数据库对应的实例，使用该实例就可以创建对应的connection,command 和adapater等等对象
provider = dbproviderfactories.getfactory(providername);
//创建具体的数据库连接类型和命令执行类型
conn = provider.createconnection();
conn.connectionstring = configurationmanager.connectionstrings["connstr"].connectionstring;
cmd = provider.createcommand();
cmd.connection = conn;
//创建具体的参数类型
para = provider.createparameter();
//创建具体的适配器类型
adapter = provider.createdataadapter();
//不同数据库参数前缀格式化
parametersformat = new dictionary<type, string>();
parametersformat.add(typeof(system.data.sqlclient.sqlcommand), "@{0}");//因sql server只返回{0}没有@前缀,在此初始化处理
//返回格式化标志
retparaformat = getparameterformat(cmd);
}

上面那段代码中，可以看到我定义了两个公共变量，其中conn在外部只会有一个地方调用它，那就就是执行datareader方法的时候了，因为大家都知道dr在离开方法体时，连接是不能关闭的，
所以只能在外部调用处显示关闭连接对象 ，必须定义为公共类型了，还有一个公共参数变量是格式化字符串的字符型。前面说到oracle参数前缀是冒号：，其它几个数据库前缀是@符号，怎么样在切换数据库以后程序能动态识别参数前缀并组合相应的参数变量呢？如果手动写代码用数据库对象类型枚举去一个个判断，那这数据库工厂也没什么意义了，最终找到了一个相当完美的解决方式（微软就是微软，都能替你想到，别人想不强大都难啦，呵呵），其实在做测试的时侯到各不同数据库的参数前缀这就有点犯难了，手写代码一个个处理吧，没问题，觉得应该有简单的方法吧，ms从来就不是傻瓜呀，正好前两天在园子首页就有篇提到这个问题，而且给出相关提示，根据给的提示再gg了一把，终于找到了一个便捷的办法。还是贴方法代码好了，如下：

/// <summary>
/// 根据不同的数据库命令对象返回该类型数据库参数的前缀格式化字符串
/// </summary>
/// <param name="command"></param>
/// <returns></returns>
private string getparameterformat(dbcommand command)
{
if (!parametersformat.containskey(command.gettype()))
{
this.open();//读取参数前缀时需打开数据库连接
parametersformat.add(
command.gettype(),
command.connection.getschema("datasourceinformation")
.rows[0]["parametermarkerformat"].tostring());
//conn.close();在真正执行语句的时候去关闭，避免重复打开
}
return parametersformat[command.gettype()];
}

就是这个了 parametermarkerformat，即参数标志符格式化，如连接oracle数据库则返回:{0}，其它几个数据库返回@{0}，惟独sql server数据库返回{0}，到底是ｍｓ自己的东西，就是要返回跟别人不一样的东西，也就因为这个，这个类库里很遗憾不得不出现一个sqlcommand，就是上面贴出的构造函数里的初始化那parametersformat.add(typeof(system.data.sqlclient.sqlcommand), "@{0}");必须这样做下处理，另外包括getparameterformat方法里的判断，即不是sql server数据库时才去读参数前缀，如果是就直接返回@{0}，有了这个格式化的前缀字符串，就好办了．那参数名称的赋值就可以类似这样了string.format("@{0}", paraname);
下面说说各通用的方法和调用，之前的sqlhelper.cs,oraclehelper.cs,xxhelper.cs中的执行方法大多都很多，有带参数执行的语句的方法，不带参数执行的语句的方法，带参数执行的方法体里面还要循环参数，这些都我都精简掉了，最终演变成了peacehelper.cs（开个玩笑）．带参执行和不带参执行dml语句，其实是可以合并成一个方法，各个参数都是保存在数据库命令对象的参数集合中的，我们可以把创建好的命令对象返回给外部程序调用处，调用的地方要带参执行语句的话，就定义参数并赋值就行了，不带参执行的话就不用定义参数了，这么以来就只需要写一个方法就行了，而且执行带掺的语句时不用再循环参数集合了，因为在调用处定义参数时，该参数已经绑定都了dbcommand对象了．写一个返回给外部调用的数据库命令对象的方法，如下：

/// <summary>
/// 抽象参数集合类型
/// </summary>
/// <returns></returns>
public dbparametercollection getparmcollection()
{
return cmd.parameters;
}

添加参数的方法如下：

/// <summary>
/// 添加参数
/// </summary>
/// <param name="paraname">参数名称</param>
/// <param name="sqltype">参数数据类型</param>
/// <param name="paravalue">参数值</param>
/// <param name="paracollect">参数对象的集合</param>
public void addparam(string paraname, dbtype sqltype, object paravalue, dbparametercollection paracollect)
{
//不允许将一个dbcommand对象的parameters插入到另外一个dbcommand对象，那么多个参数的话可以加上下面一句判断
//如果已经存在至少一个对象时，再深层拷贝一个
if (paracollect.count >= 1)
{
para = (dbparameter)((icloneable)paracollect[0]).clone();
}
para.parametername = string.format(retparaformat, paraname);
para.dbtype = sqltype;
if (paravalue == null)
{
para.value = string.empty;//dbnull.value;
}
else
{
para.value = paravalue;
}
paracollect.add(para);
}

上面有句判断，如果有多个参数会出异常，网上搜了下，注释就是网上的解释，不多说了，意思很清楚。这个方法里还有一点，如果dbtype参数不要的话测试也是可以通过的，猜想如果不显示指定参数数据类型的话，是不是都默认为object类型？这样的话会不会涉及一个装拆箱的操作呢？但是开发人员在调用处添加参数，是不应该关心参数的数据类型才对，干脆数据类型参数不要了，改成如下方法了：

public void addparam(string paraname, object paravalue, dbparametercollection paracollect)
{
if (paracollect.count >= 1)
{
para = (dbparameter)((icloneable)paracollect[0]).clone();
}
para.parametername = string.format(retparaformat, paraname);//将参数格式化为具体的数据库参数格式
if (paravalue == null)
{
para.value = string.empty;
}
else
{
para.value = paravalue;
}
paracollect.add(para);
}

为了兼容不同的数据库(主要是oracle变量特殊问题)，添加参数的方法分两种，一种是普通带参执行的dml语句，一种是代参执行的存储过程。对于sql server数据库即使是存储过程
变量参数仍是@前缀，oracle存储过程又是什么前缀呢？很遗憾，oracle存储过程的参数变量是不需要任何前缀的，为了单独兼容这一点，对于不同数据库如果调用的存储过程有参数
的话，建议用下面的三个添加参数的方法：

/// <summary>
/// 存储过程输入参数
/// </summary>
/// <param name="paraname"></param>
/// <param name="paravalue"></param>
/// <param name="paracollect"></param>
public void addinputparam(string paraname, object paravalue, dbparametercollection paracollect)
{
if (paracollect.count >= 1)
{
para = (dbparameter)((icloneable)paracollect[0]).clone();
}
para.parametername = string.format(retparaformat.replace(":",""), paraname);//oracle存储过程参数前没有冒号
if (paravalue == null)
{
para.value = string.empty;
}
else
{
para.value = paravalue;
}
paracollect.add(para);
}
/// <summary>
/// 存储过程输出参数
/// </summary>
/// <param name="paraname"></param>
/// <param name="paravalue"></param>
/// <param name="paracollect"></param>
public void addoutputparam(string paraname, dbparametercollection paracollect)
{
if (paracollect.count >= 1)
{
para = (dbparameter)((icloneable)paracollect[0]).clone();
}
para.parametername = string.format(retparaformat.replace(":", ""), paraname);
para.value = string.empty;
paracollect.add(para);
paracollect[para.parametername].direction = system.data.parameterdirection.output;//指定该参数为输出参数
}
/// <summary>
/// 存储过程返回值参数
/// </summary>
/// <param name="paraname"></param>
/// <param name="paravalue"></param>
/// <param name="paracollect"></param>
public void addreturnparam(string paraname,dbparametercollection paracollect)
{
if (paracollect.count >= 1)
{
para = (dbparameter)((icloneable)paracollect[0]).clone();
}
para.parametername = string.format(retparaformat.replace(":", ""), paraname);
para.value = string.empty;
paracollect.add(para);
paracollect[para.parametername].direction = system.data.parameterdirection.returnvalue;//指定该参数为返回值参数
}

ok，现在开始说下peacehelper.cs里的八大方法(其实算起来应该是10个)，应该来说涵盖绝大多应该系统操作数据库的绝大部分功能，如果有特殊的操作可以在此基础上添加。
第一个，大家都熟悉的返回结果集：

/// <summary>
/// 执行sql并返回数据集
/// </summary>
/// <param name="sql"></param>
/// <returns></returns>
public dataset execdataset(string sql)
{
dataset ds = new dataset();
try
{
this.open();
cmd.commandtext = replace(sql);
adapter.selectcommand = cmd;
adapter.fill(ds);
}
catch (exception ex)
{
throw ex;
}
finally
{
this.close();
}
return ds;
}

上面的方法大家看了是不是觉得既简单又熟悉，确实是的，但仍然相当以前的xxhelper.cs里是做了简化的，该方法既可以直接执行不带参dml语句，也可以执行带参的，但是该方法的形参却
只有一个，之前的xxhelper.cs里带参执行的话，形参中大多至少还另外一个形参的，比如sqlperemeters[]类型或参数集合类型的形参，而且方法体里面大多会循环读取参数，上面的方法里
却没有，都简化掉了，唯一多了一点的是，所执行的命令语句执行前要做一个特殊字符替换，cmd.commandtext = replace(sql)，replace方法主要是替换参数前缀，replace方法如下：

/// <summary>
/// 替换dml语句里的参数前缀
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public string replace(string str)
{
return str.replace("$", retparaformat.substring(0, 1));
}

因为不同数据库除了在添加参数时有前缀的区别，再具体执行语句时也有前缀区别嘛，比如sql server里 select user_name,user_age from users where user_id=@user_id，oracle里是这样的select user_name,user_age from users where user_id=:user_id，在此就需要统一一个前缀规则了，统一这样select user_name,user_age from users where user_id=$user_id，在执行前根据不同数据库替换前缀$符号，当然这个约定规则不一定是最完美的，也许还存在一定的问题，写到这我也突然想起来之前我见过别人
的系统中有的就是变量参数用的这种类似特殊符号，肯定也是为了兼容多数据库所作的处理了，呵呵，具体的调用及测试之后统一说明。还有几个方法也和上面类似，大家都熟悉的。如下（不再做具体解释了）：

/// <summary>
/// 执行sql语句并返回datareader对象
/// </summary>
/// <param name="dbcon"></param>
/// <param name="cmdtext"></param>
/// <returns></returns>
public dbdatareader executedatareader(dbconnection dbcon,string cmdtext)
{
try
{
if (dbcon.state == connectionstate.closed)
{
dbcon.open();
}
cmd.commandtext = replace(cmdtext);
dbdatareader dr = cmd.executereader();
cmd.parameters.clear();
cmd.dispose();
return dr;
}
catch
{
dbcon.close();//发生异常在此处关闭，否则在调用显式处关闭
return null;
}
}

/// <summary>
/// 判断记录是否存在
/// </summary>
/// <param name="sql"></param>
/// <returns></returns>
public bool exist(string sql)
{
bool exist;
this.open();
cmd.commandtext = replace(sql);
dbdatareader dr = cmd.executereader();
if (dr.hasrows)
{
exist = true; //记录存在
}
else
{
exist = false; //记录不存在
}
dr.close();
this.close();
return exist;
}
/// <summary>
/// 执行sql语句
/// </summary>
/// <param name="sql"></param>
public void execsql(string sql)
{
try
{
this.open();
cmd.commandtext = replace(sql);
cmd.executenonquery();
cmd.dispose();
}
catch (exception ex)
{
throw ex;
}
finally
{
this.close();
}

}
/// <summary>
/// 执行sql语句,返回一个单值
/// </summary>
/// <param name="sql"></param>
/// <returns></returns>
public string returnvalue(string sql)
{
object returnvalue = string.empty;
try
{
this.open();
cmd.commandtext = replace(sql);
returnvalue = cmd.executescalar();
if (returnvalue == null)
{
returnvalue = string.empty;
}
}
catch (exception ex)
{
throw ex;
}
finally
{
this.close();
}
return returnvalue.tostring();
}
/// <summary>
/// 执行多条sql语句并启用数据库事务
/// </summary>
/// <param name="sqlstringlist"></param>
public bool execsqltran(list<string> sqlstringlist)
{
this.open();
dbtransaction trans = conn.begintransaction();
cmd.transaction = trans;
try
{
for (int n = 0; n < sqlstringlist.count; n++)
{
cmd.commandtext = replace(sqlstringlist[n]);
cmd.executenonquery();
}
trans.commit();
return true;
}
catch
{
trans.rollback();
return false;
}
finally
{
this.close();
}
}

下面说下两个存储过程，存储过程基本上分两种，返回结果集的存储过程和执行业务逻辑不返回结果集但却有返回值（如标志等），对于需要有返回值的存储过程，我个人趋向于用输出
参数代替返回值，因为都能达到一样的效果目的，而且输出参数可以有多个，也就可以根据需要能有多个所谓的“返回值”，所以我之前的开发中一直是用output参数来代替return参数。

/// <summary>
/// 执行存储过程并返回结果集
/// </summary>
/// <param name="storedprocname">存储过程名</param>
/// <returns>dataset</returns>
public dataset runprocedure(string storedprocname)
{
dataset ds = new dataset();
try
{
this.open();
cmd.commandtext = storedprocname;
cmd.commandtype = commandtype.storedprocedure;
adapter.selectcommand = cmd;
//adapter.selectcommand.commandtimeout = 1200;//可以设置适当的超时时间(秒)，避免选择时间段过大导致填充数据集超时
adapter.fill(ds);
}
catch (exception ex)
{
throw ex;
}
finally
{
this.close();
}
return ds;
}
/// <summary>
/// 执行存储过程，方法不返回结果集
/// </summary>
/// <param name="storedprocname"></param>
public void runvoidprocedure(string storedprocname)
{
cmd.commandtext = storedprocname;
cmd.commandtype = commandtype.storedprocedure;
try
{
this.open();
cmd.executenonquery();
}
catch (exception ex)
{
throw ex;
}
finally
{
this.close();
}
}

下面说两个反射方法，测试之后为了方便调用，减少操作添加的，一个是把实体类的属性转换为参数，另一个是把从数据库取出的某条记录转换为实体类，这两个还是非常有用，尤其是在系统开发时调用比较方便，以前我是见到反射就绕道走的，这次算是第一次用反射，发现确实是很方便。如下：

/// <summary>
/// 将实体类的属性进行参数转换(oracle测试通不过，必须要求所有参数都包含在语句中才行)
/// </summary>
/// <param name="model"></param>
/// <param name="paracollect"></param>
//public void converttoparameters(object model, dbparametercollection paracollect)
//{
// type t = model.gettype();
// propertyinfo[] propert = t.getproperties();
// for (int i = 0; i < propert.length; i++)
// {
// addparam(propert[i].name, propert[i].getvalue(model, null), paracollect);
// }
//}
/// <summary>
/// 将实体类的属性进行参数转换
/// </summary>
/// <param name="model"></param>
/// <param name="paracollect"></param>
public void converttoparameters(object model, dbparametercollection paracollect,list<string> fields)
{
type t = model.gettype();
propertyinfo[] propert = t.getproperties();
for (int i = 0; i < propert.length; i++)
{
if (fields.contains(propert[i].name)) //检测必须参数化的实体属性
{
addparam(propert[i].name, propert[i].getvalue(model, null), paracollect);
}
}
}

/// <summary>
/// 通过反射将取出的数据写入实体类(oracle测试通不过,需进行类型强制转换)
/// </summary>
/// <param name="model"></param>
/// <param name="cmdtext"></param>
//public void getmodel(object model, string cmdtext)
//{
// propertyinfo propertyinfo;
// dbdatareader dr = executedatareader(conn, cmdtext);
// while (dr.read())
// {
// for (int i = 0; i < dr.fieldcount; i++)
// {
// propertyinfo = model.gettype().getproperty(dr.getname(i));
// if (propertyinfo != null)
// {
// if (dr.getvalue(i) != dbnull.value)
// {
// //type t = dr.getvalue(i).gettype();
// propertyinfo.setvalue(model, dr.getvalue(i), null);
// }
// }
// }
// }
// dr.close();
// conn.close();
//}
/// <summary>
/// 通过反射将数据绑定到实体对象，由于不同数据库对应于.net的数据类型不一样
/// 需做强制类型转换
/// </summary>
/// <param name="model"></param>
/// <param name="cmdtext"></param>
public void getmodel(object model, string cmdtext)
{
propertyinfo propertyinfo;
dbdatareader dr = executedatareader(conn, cmdtext);
object _value;
while (dr.read())
{
for (int i = 0; i < dr.fieldcount; i++)
{
propertyinfo = model.gettype().getproperty(dr.getname(i));
if (propertyinfo != null && dr.getvalue(i) != dbnull.value)
{
switch (propertyinfo.propertytype.tostring())
{
case "system.string":
{
_value = convert.tostring(dr.getvalue(i));//字符串是全球通用类型，也可以不用转换
propertyinfo.setvalue(model, _value, null);
}break;
case "system.int32":
{
_value = convert.toint32(dr.getvalue(i));
propertyinfo.setvalue(model, _value, null);
} break;
case "system.single":
{
_value = convert.tosingle(dr.getvalue(i));
propertyinfo.setvalue(model, _value, null);
} break;
case "system.decimal":
{
_value = convert.todecimal(dr.getvalue(i));
propertyinfo.setvalue(model, _value, null);
} break;
case "system.double":
{
_value = convert.todouble(dr.getvalue(i));
propertyinfo.setvalue(model, _value, null);
} break;
case "":
{
_value = convert.todatetime(dr.getvalue(i));
propertyinfo.setvalue(model, _value, null);
} break;
default: break;
}
}
}
}
dr.close();
conn.close();
}

从上面的注释掉的方法对比中可以看到为了兼容不同的数据库，必须要做额外的处理，比如类型转换，sql server的int 对应oralce的number，userinfo的字段属性userage定义的是int类型，连接oralce时，.net识别number类型为system.decimal，把decimal赋值给int32当然是不行的，所以得做强制转换才行。还有一点要注意下，就是将数据绑定到实体对象时，由于oracle坚持大写标准和解析机制，如果属性名和字段名大小写不一致的话，propertyinfo = model.gettype().getproperty(dr.getname(i)) ，propertyinfo 始终是null值，比如select username,userage from user_test where userid=$userid，sql server 执行的时候调试可以看到dr.getname(0)是username,dr.getname(1)是userage，oracle执行解析就变了，全是大写了，变成了usernae,userage，这么一来和找不到userinfo类的属性了，因为userinfo类的属性是 username，和userage，c#语言变量也是区分大小写的嘛，当然就找不到了，所以propertyinfo就为null了，故在这里再次建议大家在数据库设计和程序字段属性设计时采用大写标准(如果不涉及多数据库当然也不需要这么做)。
最后说下测试调用代码，首先webconfig配置里面这样配置下，主要选取sql server和oracle做测试，毕竟这是.net支持的两个典型数据库，要是把.net所支持的所有书库都测试一遍，那测试量可不小了，呵呵。

<connectionstrings>
<add name="connstr" connectionstring="uid=sa;pwd=peace;database=test;server=." providername="system.data.sqlclient" />
<!--<add name="connstr" connectionstring="server=.;data source=peace;user id=cct;password=cct;enlist=true" providername="system.data.oracleclient"/>-->
</connectionstrings>


protected void page_load(object sender, eventargs e)
{
//测试datareader,sqlserver和oracle都通过
//dataproviderfactory fac = new dataproviderfactory();
//dbparametercollection paracollect = fac.getparmcollection();
//fac.addparam("userid", 100, paracollect);
//dbdatareader dr = fac.executedatareader(fac.conn, "select * from user_test where userid=$userid");
//while (dr.read())
//{
// string a = dr[1].tostring();
//}
//fac.conn.close();//在调用处显示关闭

//无参数dataset测试 sqlserver和oracle都通过
//datatable dt = fac.execdataset("select * from user_test").tables[0];
//带参数dataset测试 sqlserver和oracle都通过
//dbparametercollection paracollect = fac.getparmcollection();
//fac.addparam("userid", 100, paracollect);
//fac.addparam("username", "局%", paracollect);//这里的参数名可以任意成其它，不一定非要和字段名相同（下同）
//datatable dt = fac.execdataset("select * from user_test where username like $username").tables[0];
//datatable dt = fac.execdataset("select * from user_test where userid=$userid or username like $username").tables[0];//多参数测试
//单值测试(带参数) sqlserver和oracle都通过
//dbparametercollection paracollect = fac.getparmcollection();
//fac.addparam("userid", 100, paracollect);
//string retvalue = fac.returnvalue("select username from user_test where userid=$userid");
//带参存储过程测试返回结果集 sqlserver和oracle都通过
//dbparametercollection paracollect = fac.getparmcollection();
//fac.addparam("startdate", "2009-8-1", paracollect);
//fac.addparam("enddate", "2009-8-21", paracollect);
//datatable dt = fac.runprocedure("usp_getmixedreport").tables[0];

//带参数测试存储过程的输出参数值和返回值，方法不返回结果集 sqlserver通过
//int flag = 0, sign = 0, ret = 0;
//dbparametercollection paracollect = fac.getparmcollection();
//fac.addparam("user_account", dbtype.string, "admin", paracollect);
//fac.addparam("user_pwd", dbtype.string, "68053af2923e00204c3ca7c6a3150cf7", paracollect);
//fac.addparam("flag", dbtype.int32, "", paracollect);
//paracollect["@flag"].direction = system.data.parameterdirection.output;
//fac.addparam("sign", dbtype.int32, "", paracollect);
//paracollect["@sign"].direction = system.data.parameterdirection.output;
//fac.addparam("retvalue", dbtype.string, "", paracollect);
//paracollect["@retvalue"].direction = system.data.parameterdirection.returnvalue;
//fac.runvoidprocedure("sp_validelogin");
//flag = int.parse(paracollect["@flag"].value.tostring());
//sign = int.parse(paracollect["@sign"].value.tostring());
//ret = int.parse(paracollect["@retvalue"].value.tostring());//存储过程约定返回值必须是int型

//改进后带参数测试存储过程的输出参数值和返回值的测试 sqlserver和oracle都通过
//int flag = 0, sign = 0, ret = 0;
//dataproviderfactory fac = new dataproviderfactory();
//dbparametercollection paracollect = fac.getparmcollection();
//fac.addinputparam("user_account", "admin", paracollect);
//fac.addinputparam("user_pwd", "68053af2923e00204c3ca7c6a3150cf7", paracollect);
//fac.addoutputparam("flag", paracollect);
//fac.addoutputparam("sign", paracollect);
//fac.addreturnparam("retvalue", paracollect);
//fac.runvoidprocedure("sp_validelogin");
//string prefix = fac.retparaformat.replace(":","");//oracle存储过程参数前冒号移除掉
//flag = int.parse(paracollect[string.format(prefix,"flag")].value.tostring());
//sign = int.parse(paracollect[string.format(prefix, "sign")].value.tostring());
//ret = int.parse(paracollect[string.format(prefix, "retvalue")].value.tostring());//存储过程约定返回值必须是int型

//调用存储过程测试 sqlserver和oracle都通通过
//dataproviderfactory fac = new dataproviderfactory();
//dbparametercollection paracollect = fac.getparmcollection();
//fac.addinputparam("p_userid", 7, paracollect);
//fac.addinputparam("p_username", "peace", paracollect);
//fac.addinputparam("p_userage", 100, paracollect);
//fac.runvoidprocedure("proc_user_test_add");
//多条提交事务处理测试 sqlserver和oracle都通过
//list<string> sqllist = new list<string>();
//dataproviderfactory fac = new dataproviderfactory();
//dbparametercollection paracollect = fac.getparmcollection();
//fac.addparam("username", "peaceli", paracollect);
//fac.addparam("userage", 150, paracollect);
//sqllist.add("insert into user_test(username,userage) values($username,$userage)");
//sqllist.add("insert into user_test(username,userage) values($username,$userage)");
//sqllist.add("insert into user_test(username,userage) values($username,$userage)");
//fac.execsqltran(sqllist);
//插入操作参数测试(sql server) 通过
//userinfo ui = new userinfo();
//ui.username = "hello peace";
//ui.userage = 100;
//addinn(ui);
//插入操作参数测试(oracle) 通过
//userinfo ui = new userinfo();
//ui.userid = 10;
//ui.username = "hello peace";
//ui.userage = 120;
//addin(ui);
//插入操作反射参数转换测试 sqlserver和oracle都通过
//userinfo ui = new userinfo();
//ui.username = "peaceli";
//ui.userage = 110;
//add(ui);
//返回实体对象测试 sqlserver和oracle都通过
userinfo ui = new userinfo();
ui.userid = 1;
getinfo(ui);
}
//private void addinn(userinfo ui)
//{
// dataproviderfactory fac = new dataproviderfactory();
// dbparametercollection paracollect = fac.getparmcollection();
// fac.addparam("@username", ui.username, paracollect);
// fac.addparam("@userage", ui.userage, paracollect);
// fac.execsql("insert into user_test(username,userage) values(@username,@userage)");
//}
private void addin(userinfo ui)
{
dataproviderfactory fac = new dataproviderfactory();
dbparametercollection paracollect = fac.getparmcollection();
//fac.addparam(":username", ui.username, paracollect);//给参数赋值时冒号可以不加，但有的版本可能必须加
//fac.addparam(":userage", ui.userage, paracollect);
//fac.addparam("userid", ui.userid, paracollect); //这行注释放开在oracle下同不过，oracle要求所全参数匹配，有多余参数就不行，这点有些变态
fac.addparam("username", ui.username, paracollect);//sql server只要求用到的参数包含在参数集合里就行了，其它多余参数并不影响执行
fac.addparam("userage", ui.userage, paracollect);
fac.execsql("insert into user_test(username,userage) values(:username,:userage)");
}
private void add(userinfo ui)
{
dataproviderfactory fac = new dataproviderfactory();
dbparametercollection paracollect = fac.getparmcollection();
string[] fields = { "username", "userage" };//要求参数化的实体属性
list<string> listfields = new list<string>(fields);
fac.converttoparameters(ui, paracollect, listfields);//如果新增记录有很多参数的话，可能addparam很多次，采用反射批量转换
fac.execsql("insert into user_test(username,userage) values($username,$userage)");
}
private void getinfo(userinfo ui)
{
dataproviderfactory fac = new dataproviderfactory();
dbparametercollection paracollect = fac.getparmcollection();
fac.addparam("userid", ui.userid, paracollect);
fac.getmodel(ui, "select username,userage from user_test where userid=$userid");
}
}

userinfo类如下：

public class userinfo
{
public int userid { get; set; }
public string username { get; set; }
public int userage { get; set; }
}

测试到最后类属性改动过，统一改成了大写，再次建议大写标准(包括数据库设计)，可以定义成user_id,user_name,user_age等，并与数据库字段名保持一致，这样有利于多数据库的
兼容。
结语：个人并不反对项目里单独用对应的xxhelper.cs，某个项目用sqlserver数据库，就用sqlhelper.csl类，oracle就用oraclehelper.cs类，这样来得更干脆快捷，基本上每个项目都是这对特定的数据库在开发，没必要搞成通用类，真要搞成通用类，要经过大量的实际测试，也许我最近有时寂寞空虚也无聊，突然想测试下同时也想改进下，呵呵，零零碎碎花了点时间测试了下，选取两个数据库测试了一遍，最终只需要改动config配置的数据库连接就可以了，真正达到了一套系统的无缝切换。里面有些可能还说的不够准确，可能也还有遗漏的地方，仅供参考吧！！！
访问类库的文件完整的贴一次，如下：

//*****************************************************************************************************************
//* 编写人 ：peace
//* email : [e-mail]
//* 开发日期：2009-10-21
//* 修 改 人：
//* 修改日期：
//* 描 述：数据库工厂访问类
//* 更新描述：里面供调用执行的各方法可带参数执行，在外部指定参数名和参数值即可。
//* 最终期望：支持.net所支持的所有数据库并达到系统的无缝切换（尽情的忽悠吧o(∩_∩)o~）
//*****************************************************************************************************************
using system;
using system.collections;
using system.collections.generic;
using system.linq;
using system.text;
using system.data;
using system.data.common;
using system.configuration;
using system.reflection;
namespace dataprovider
{
public class dataproviderfactory
{
public dbconnection conn;//抽象类型
private dbcommand cmd;//抽象类型
private dbproviderfactory provider;
private dbparameter para;//不同数据库参数类型的抽象类型
private dbdataadapter adapter;//对应不同数据库的数据适配器
dictionary<type, string> parametersformat;//不同数据库参数格式化类型
public string retparaformat = string.empty;//最终返回的格式化标志，如@{0},:{0}
public dataproviderfactory()
{
//从配置文件中取出标示数据库类型的字符串并通过providername的不同支持不同类型的数据库
string providername = configurationmanager.connectionstrings["connstr"].providername;//也可以用索引,从1开始
//创建一个数据库对应的实例，使用该实例就可以创建对应的connection,command 和adapater等等对象
provider = dbproviderfactories.getfactory(providername);
//创建具体的数据库连接类型和命令执行类型
conn = provider.createconnection();
conn.connectionstring = configurationmanager.connectionstrings["connstr"].connectionstring;
cmd = provider.createcommand();
cmd.connection = conn;
//创建具体的参数类型
para = provider.createparameter();
//创建具体的适配器类型
adapter = provider.createdataadapter();
//不同数据库参数前缀格式化
parametersformat = new dictionary<type, string>();
parametersformat.add(typeof(system.data.sqlclient.sqlcommand), "@{0}");//因sql server只返回{0}没有@前缀,在此初始化处理
//返回格式化标志
retparaformat = getparameterformat(cmd);
}
/// <summary>
/// 添加参数
/// </summary>
/// <param name="paraname">参数名称</param>
/// <param name="sqltype">参数数据类型</param>
/// <param name="paravalue">参数值</param>
/// <param name="paracollect">参数对象的集合</param>
public void addparam(string paraname, dbtype sqltype, object paravalue, dbparametercollection paracollect)
{
//不允许将一个dbcommand对象的parameters插入到另外一个dbcommand对象，那么多个参数的话可以加上下面一句判断
//如果已经存在至少一个对象时，再深层拷贝一个
if (paracollect.count >= 1)
{
para = (dbparameter)((icloneable)paracollect[0]).clone();
}
para.parametername = string.format(retparaformat, paraname);
para.dbtype = sqltype;
if (paravalue == null)
{
para.value = string.empty;//dbnull.value;
}
else
{
para.value = paravalue;
}
paracollect.add(para);
}
public void addparam(string paraname, object paravalue, dbparametercollection paracollect)
{
if (paracollect.count >= 1)
{
para = (dbparameter)((icloneable)paracollect[0]).clone();
}
para.parametername = string.format(retparaformat, paraname);//将参数格式化为具体的数据库参数格式
if (paravalue == null)
{
para.value = string.empty;
}
else
{
para.value = paravalue;
}
paracollect.add(para);
}
/// <summary>
/// 存储过程输入参数
/// </summary>
/// <param name="paraname"></param>
/// <param name="paravalue"></param>
/// <param name="paracollect"></param>
public void addinputparam(string paraname, object paravalue, dbparametercollection paracollect)
{
if (paracollect.count >= 1)
{
para = (dbparameter)((icloneable)paracollect[0]).clone();
}
para.parametername = string.format(retparaformat.replace(":",""), paraname);//oracle存储过程参数前没有冒号
if (paravalue == null)
{
para.value = string.empty;
}
else
{
para.value = paravalue;
}
paracollect.add(para);
}
/// <summary>
/// 存储过程输出参数
/// </summary>
/// <param name="paraname"></param>
/// <param name="paravalue"></param>
/// <param name="paracollect"></param>
public void addoutputparam(string paraname, dbparametercollection paracollect)
{
if (paracollect.count >= 1)
{
para = (dbparameter)((icloneable)paracollect[0]).clone();
}
para.parametername = string.format(retparaformat.replace(":", ""), paraname);
para.value = string.empty;
paracollect.add(para);
paracollect[para.parametername].direction = system.data.parameterdirection.output;//指定该参数为输出参数
}
/// <summary>
/// 存储过程返回值参数
/// </summary>
/// <param name="paraname"></param>
/// <param name="paravalue"></param>
/// <param name="paracollect"></param>
public void addreturnparam(string paraname,dbparametercollection paracollect)
{
if (paracollect.count >= 1)
{
para = (dbparameter)((icloneable)paracollect[0]).clone();
}
para.parametername = string.format(retparaformat.replace(":", ""), paraname);
para.value = string.empty;
paracollect.add(para);
paracollect[para.parametername].direction = system.data.parameterdirection.returnvalue;//指定该参数为返回值参数
}
/// <summary>
/// 抽象参数集合类型
/// </summary>
/// <returns></returns>
public dbparametercollection getparmcollection()
{
return cmd.parameters;
}
/// <summary>
/// 执行sql并返回数据集
/// </summary>
/// <param name="sql"></param>
/// <returns></returns>
public dataset execdataset(string sql)
{
dataset ds = new dataset();
try
{
this.open();
cmd.commandtext = replace(sql);
adapter.selectcommand = cmd;
adapter.fill(ds);
}
catch (exception ex)
{
throw ex;
}
finally
{
this.close();
}
return ds;
}
/// <summary>
/// 执行sql语句并返回datareader对象
/// </summary>
/// <param name="dbcon"></param>
/// <param name="cmdtext"></param>
/// <returns></returns>
public dbdatareader executedatareader(dbconnection dbcon,string cmdtext)
{
try
{
if (dbcon.state == connectionstate.closed)
{
dbcon.open();
}
cmd.commandtext = replace(cmdtext);
dbdatareader dr = cmd.executereader();
cmd.parameters.clear();
cmd.dispose();
return dr;
}
catch
{
dbcon.close();//发生异常在此处关闭，否则在调用显式处关闭
return null;
}
}

/// <summary>
/// 判断记录是否存在
/// </summary>
/// <param name="sql"></param>
/// <returns></returns>
public bool exist(string sql)
{
bool exist;
this.open();
cmd.commandtext = replace(sql);
dbdatareader dr = cmd.executereader();
if (dr.hasrows)
{
exist = true; //记录存在
}
else
{
exist = false; //记录不存在
}
dr.close();
this.close();
return exist;
}
/// <summary>
/// 执行sql语句
/// </summary>
/// <param name="sql"></param>
public void execsql(string sql)
{
try
{
this.open();
cmd.commandtext = replace(sql);
cmd.executenonquery();
cmd.dispose();
}
catch (exception ex)
{
throw ex;
}
finally
{
this.close();
}

}
/// <summary>
/// 执行sql语句,返回一个单值
/// </summary>
/// <param name="sql"></param>
/// <returns></returns>
public string returnvalue(string sql)
{
object returnvalue = string.empty;
try
{
this.open();
cmd.commandtext = replace(sql);
returnvalue = cmd.executescalar();
if (returnvalue == null)
{
returnvalue = string.empty;
}
}
catch (exception ex)
{
throw ex;
}
finally
{
this.close();
}
return returnvalue.tostring();
}
/// <summary>
/// 执行多条sql语句并启用数据库事务
/// </summary>
/// <param name="sqlstringlist"></param>
public bool execsqltran(list<string> sqlstringlist)
{
this.open();
dbtransaction trans = conn.begintransaction();
cmd.transaction = trans;
try
{
for (int n = 0; n < sqlstringlist.count; n++)
{
cmd.commandtext = replace(sqlstringlist[n]);
cmd.executenonquery();
}
trans.commit();
return true;
}
catch
{
trans.rollback();
return false;
}
finally
{
this.close();
}
}

/// <summary>
/// 执行存储过程并返回结果集
/// </summary>
/// <param name="storedprocname">存储过程名</param>
/// <returns>dataset</returns>
public dataset runprocedure(string storedprocname)
{
dataset ds = new dataset();
try
{
this.open();
cmd.commandtext = storedprocname;
cmd.commandtype = commandtype.storedprocedure;
adapter.selectcommand = cmd;
//adapter.selectcommand.commandtimeout = 1200;//可以设置适当的超时时间(秒)，避免选择时间段过大导致填充数据集超时
adapter.fill(ds);
}
catch (exception ex)
{
throw ex;
}
finally
{
this.close();
}
return ds;
}
/// <summary>
/// 执行存储过程，方法不返回结果集
/// </summary>
/// <param name="storedprocname"></param>
public void runvoidprocedure(string storedprocname)
{
cmd.commandtext = storedprocname;
cmd.commandtype = commandtype.storedprocedure;
try
{
this.open();
cmd.executenonquery();
}
catch (exception ex)
{
throw ex;
}
finally
{
this.close();
}
}

/// <summary>
/// 将实体类的属性进行参数转换(oracle测试通不过，必须要求所有参数都包含在语句中才行)
/// </summary>
/// <param name="model"></param>
/// <param name="paracollect"></param>
//public void converttoparameters(object model, dbparametercollection paracollect)
//{
// type t = model.gettype();
// propertyinfo[] propert = t.getproperties();
// for (int i = 0; i < propert.length; i++)
// {
// addparam(propert[i].name, propert[i].getvalue(model, null), paracollect);
// }
//}
/// <summary>
/// 将实体类的属性进行参数转换
/// </summary>
/// <param name="model"></param>
/// <param name="paracollect"></param>
public void converttoparameters(object model, dbparametercollection paracollect,list<string> fields)
{
type t = model.gettype();
propertyinfo[] propert = t.getproperties();
for (int i = 0; i < propert.length; i++)
{
if (fields.contains(propert[i].name)) //检测必须参数化的实体属性
{
addparam(propert[i].name, propert[i].getvalue(model, null), paracollect);
}
}
}

/// <summary>
/// 通过反射将取出的数据写入实体类(oracle测试通不过,需进行类型强制转换)
/// </summary>
/// <param name="model"></param>
/// <param name="cmdtext"></param>
//public void getmodel(object model, string cmdtext)
//{
// propertyinfo propertyinfo;
// dbdatareader dr = executedatareader(conn, cmdtext);
// while (dr.read())
// {
// for (int i = 0; i < dr.fieldcount; i++)
// {
// propertyinfo = model.gettype().getproperty(dr.getname(i));
// if (propertyinfo != null)
// {
// if (dr.getvalue(i) != dbnull.value)
// {
// //type t = dr.getvalue(i).gettype();
// propertyinfo.setvalue(model, dr.getvalue(i), null);
// }
// }
// }
// }
// dr.close();
// conn.close();
//}
/// <summary>
/// 通过反射将数据绑定到实体对象，由于不同数据库对应于.net的数据类型不一样
/// 需做强制类型转换
/// </summary>
/// <param name="model"></param>
/// <param name="cmdtext"></param>
public void getmodel(object model, string cmdtext)
{
propertyinfo propertyinfo;
dbdatareader dr = executedatareader(conn, cmdtext);
object _value;
while (dr.read())
{
for (int i = 0; i < dr.fieldcount; i++)
{
propertyinfo = model.gettype().getproperty(dr.getname(i));
if (propertyinfo != null && dr.getvalue(i) != dbnull.value)
{
switch (propertyinfo.propertytype.tostring())
{
case "system.string":
{
_value = convert.tostring(dr.getvalue(i));//字符串是全球通用类型，也可以不用转换
propertyinfo.setvalue(model, _value, null);
}break;
case "system.int32":
{
_value = convert.toint32(dr.getvalue(i));
propertyinfo.setvalue(model, _value, null);
} break;
case "system.single":
{
_value = convert.tosingle(dr.getvalue(i));
propertyinfo.setvalue(model, _value, null);
} break;
case "system.decimal":
{
_value = convert.todecimal(dr.getvalue(i));
propertyinfo.setvalue(model, _value, null);
} break;
case "system.double":
{
_value = convert.todouble(dr.getvalue(i));
propertyinfo.setvalue(model, _value, null);
} break;
case "":
{
_value = convert.todatetime(dr.getvalue(i));
propertyinfo.setvalue(model, _value, null);
} break;
default: break;
}
}
}
}
dr.close();
conn.close();
}
/// <summary>
/// 根据不同的数据库命令对象返回该类型数据库参数的前缀格式化字符串
/// </summary>
/// <param name="command"></param>
/// <returns></returns>
private string getparameterformat(dbcommand command)
{
if (!parametersformat.containskey(command.gettype()))
{
this.open();//读取参数前缀时需打开数据库连接
parametersformat.add(
command.gettype(),
command.connection.getschema("datasourceinformation")
.rows[0]["parametermarkerformat"].tostring());
//conn.close();在真正执行语句的时候去关闭，避免重复打开
}
return parametersformat[command.gettype()];
}
private void open()
{
if (conn.state == connectionstate.closed)
{
conn.open();
}
}
private void close()
{
if (conn.state == connectionstate.open)
{
conn.close();
}
}
/// <summary>
/// 替换dml语句里的参数前缀
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public string replace(string str)
{
return str.replace("$", retparaformat.substring(0, 1));
}
}
}

文件下载：peacehelper.cs