[求助]C#怎么写数据库连接能实用所有数据库

[ChinaBruceHe]

[求助]C# 怎么写 数据库 连接 或者 配置文件 能实用 所有数据库（如SQL,Oracle,ACESS等）
谢谢，新手！

[bluedoctor]

如果光是SQL,Oracle,ACESS这三个,可以使用OLEDB驱动方式，如果想要更多，就只有ODBC方式了。

[十八道胡同]

所有数据库？？


一个数据库一个连接的啊，所有啊....

[T_T_zz]

ODBC，自建连接字符串

[bluedoctor]

如果楼主想实现你的程序可以使用各种数据库，那么请看我的博客 ，下载一个 PDF.NET框架，里面的Web.config里面有如何连接各种数据库的例子。

[专坑开发的产品]

写一个接口.
然后每一个种数据库写一个DLL.
在程序里用assembly.load来调用.

[ChinaBruceHe]

呵呵，有没有具体的哦？

[bluedoctor]

我的框架里面有具体的例子。

[龙宜坡]

通用的代价就是性能。

声明接口，针对各种DB实现之。

[Dobzhansky]

简单的需求用 2.0 就可以了,

DbConnection
DBCommand
...

统一靠 ProviderName, 籍由 DbProviderFactory 来创建.

但稍微深入, 统一是不可能的, 可以用类型层次规划来实现抽象上的一致,
真正的干活的地方想一样是不鸡巴可能的.

[ChinaBruceHe]

[Quote=引用 2 楼 bluedoctor 的回复:]
如果光是SQL,Oracle,ACESS这三个,可以使用OLEDB驱动方式，如果想要更多，就只有ODBC方式了。
[/Quote]

怎么弄，能附个网址么，谢谢

[WTPMCheng]

[Quote=引用 8 楼 dobzhansky 的回复:]
简单的需求用 2.0 就可以了,

DbConnection
DBCommand
...

统一靠 ProviderName, 籍由 DbProviderFactory 来创建.
[/Quote]

使用Connection,Command的基类，DbConnection,和DBCommand 在用个枚举去列出你要连接的类型，sql,oledb,oracle等，用sql的时候就使用sqlConnection和sqlCommand，依此类推！！

先试试看！！但是连接字符还是得自己写，要驱动就要写驱动。。。。

或者是参考楼上的朋友，一个写一个个连接，也行！！

[liangchencf]

所有数据库应该包含两层含义，一是驱动、二是执行的sql语法。只有两个都能满足才能保证在移植程序时改动最小。
首先驱动上由于各个数据库提供的驱动都集成或实现自ado.net中的虚基类或者借口，实现上比较好办。
比如：
public abstract class SqlOperatorBase<Connection, DataAdapter, DataReader, DataCommand, Parameter> : ISqlOperator
where Connection : IDbConnection, new()
where DataAdapter : DbDataAdapter, new()
where DataReader : IDataReader
where DataCommand : IDbCommand, new()
where Parameter : IDbDataParameter, IDataParameter, new(){
open();
close();
select();
...
}
其次就是语法，这个比较麻烦，除非自己封装一层，否则不是太好解决，即使很小的差异都不行。不过基本查询逻辑都是一样的。
我倒是写过一个，相当于再把查询封装一下。不写明文的sql还可以。
或者可以看看nherbnit（忘了拼写了...）

[sakabi]

using System;
using System.Data.OleDb;
using System.IO;
using System.Configuration;
//using System.Data.OracleClient;
namespace Common
{
/// <summary>
/// 支持连接池的数据库访问类
/// </summary>
public class ClsDB
{
//连接池
static private System.Collections.ArrayList ConnArr = new System.Collections.ArrayList();
public ClsDB()
{
//
// TODO: 在此处添加构造函数逻辑
//
}

/// <summary>
/// 从连接池中得到一个可用连接
/// </summary>
/// <returns>返回一个类型无关的可用连接</returns>
static public System.Data.IDbConnection getConn()
{
//遍历连接池
for (int i = ClsDB.ConnArr.Count -1; i >= 0;i-- )
{
if (ClsDB.ConnArr[i] == null)
{ //如果连接对象为空则清除该连接
ClsDB.ConnArr.Remove(ClsDB.ConnArr[i]);
}
else if (((System.Data.IDbConnection)ClsDB.ConnArr[i]).State == System.Data.ConnectionState.Closed)
{ //如果连接对象状态为关闭则打开后返回该对象
System.Data.IDbConnection Conn = (System.Data.IDbConnection)ClsDB.ConnArr[i];
ClsDB.OpenConnect(ref Conn);
return Conn;

}
else if (((System.Data.IDbConnection)ClsDB.ConnArr[i]).State == System.Data.ConnectionState.Open)
{ //如果连接对象状态为打开则返回该对象
return (System.Data.IDbConnection)ClsDB.ConnArr[i];
}
}
//如果连接池中无可用连接则创建新连接
System.Data.IDbConnection NewConn = null;
if (ClsDB.OpenConnect(ref NewConn))
{
ClsDB.ConnArr.Add(NewConn);
return NewConn;
}
else
{ //创建新连接失败则返回 null
NewConn.Dispose();
NewConn = null;
return null;
}
}

/// <summary>
/// 得到连接字符串
/// </summary>
/// <returns>连接字符串</returns>
static public string getConnString()
{
string connStr = ConfigurationManager.ConnectionStrings["ConnectionString"].ToString();
if (connStr == null || connStr == "")
{
Common.ErrLog("ClsDB.getConnString():ConnectionString为空");
}
return connStr;
}
/// <summary>
/// 打开数据库连接
/// </summary>
/// <returns></returns>
static public bool OpenConnect(ref System.Data.IDbConnection Conn)
{
if (Conn == null)
{
string connType = "";
try
{
connType = ConfigurationManager.ConnectionStrings["ConnectionType"].ToString();
if (connType == null || connType == "")
{
Common.ErrLog("ClsDB.OpenConnect():ConnectionType为空");
}
}
catch (Exception ex)
{
Common.ErrLog(ex.Message);
}
switch(connType.ToLower())
{
case "sqlserver":
Conn = new System.Data.SqlClient.SqlConnection();
break;
//case "oracle":
//Conn = new System.Data.OracleClient.OracleConnection();
//break;
case "oledb":
Conn = new System.Data.OleDb.OleDbConnection();
break;
case "odbc":
Conn = new System.Data.Odbc.OdbcConnection();
break;
default:
Conn = new System.Data.OleDb.OleDbConnection();
break;
}
}
else if(Conn.State==System.Data.ConnectionState.Open)
{
Conn.Close();
}
Conn.ConnectionString = getConnString();
try
{
Conn.Open();
return true;
}
catch(InvalidOperationException eix)
{
Common.ErrLog("ClsDB.OpenConnect():" + eix.Message);
return false;
}
catch(OleDbException ex)
{
Common.ErrLog("ClsDB.OpenConnect():" + ex.Message);
return false;
}

}//OpenConnect(System.Data.IDbConnection Conn)

/// <summary>
/// 关闭数据库连接
/// </summary>
/// <returns></returns>
static public void CloseConnect()
{
foreach (System.Data.IDbConnection conn in ConnArr)
{
if (conn.State == System.Data.ConnectionState.Open)
{
conn.Close();
conn.Dispose();
}
}
ConnArr.Clear();

}//CloseConnect()

/// <summary>
/// 执行查询返回DataTable
/// </summary>
/// <param name="sql">Sql语句</param>
/// <returns>成功返回DataTable,失败则返回 null</returns>
static public System.Data.DataTable ExecuteQueryToDataTable(string sql)
{
System.Data.DataTable table = new System.Data.DataTable();
System.Data.DataRow row = null;
try
{
System.Data.IDataReader reader = ClsDB.ExecuteQuery(sql);
if (reader != null)
{
for (int i = 0; i < reader.FieldCount; i++)
{
table.Columns.Add(reader.GetName(i));
}
while (reader.Read())
{
row = table.NewRow();
for (int i = 0; i < reader.FieldCount; i++)
{
row[i] = reader[i].ToString();
}
table.Rows.Add(row);
}
reader.Close();
return table;
}
else
{
return null;
}
}
catch(Exception ex)
{
Common.ErrLog("ClsDB.ExecuteQueryToDataTable(string sql):" + ex.Message);
return null;
}
}//ExecuteQueryToDataTable(string sql)


/// <summary>
/// 执行查询返回DataReader
/// </summary>
/// <param name="sql">Sql语句</param>
/// <returns>失败时返回null</returns>
static public System.Data.IDataReader ExecuteQuery(string sql)
{
System.Data.IDbConnection Conn = ClsDB.getConn();
System.Data.IDataReader reader = null;
if (Conn == null)
{
return null;
}
try
{
System.Data.IDbCommand cmd = Conn.CreateCommand();
cmd.CommandText=sql;
reader=cmd.ExecuteReader();
return reader;
}
catch(Exception ex)
{
Common.ErrLog("ClsDB.ExecuteQuery(string sql):" + ex.Message);
return null;
}

}//ExecuteQuery(string sql)

[sakabi]

太多，接楼上
/// <summary>
/// 执行Sql语句
/// </summary>
/// <param name="sql">Sql语句</param>
/// <returns>返回受影响行数</returns>
static public int Execute(string sql)
{
System.Data.IDbConnection Conn = ClsDB.getConn();
if (Conn == null)
{
Common.ErrLog("ClsDB.Execute(string sql):连接对象为空!");
return 0;
}
System.Data.IDbCommand cmd = Conn.CreateCommand();

cmd.CommandText=sql;
try
{
return cmd.ExecuteNonQuery();
}
catch(Exception ex)
{
Common.ErrLog("ClsDB.ExecuteQuery(string sql):" + ex.Message+"/nsql="+sql);
return 0;
}
}//Execute(string sql)

/// <summary>
/// 执行Sql语句
/// </summary>
/// <param name="sql">Sql语句</param>
/// <param name="param">参数</param>
/// <returns>返回受影响行数</returns>
static public int Execute(string sql,System.Data.IDataParameter[] param)
{
System.Data.IDbConnection Conn = ClsDB.getConn();
if (Conn == null)
{
Common.ErrLog("ClsDB.Execute(string sql,System.Data.IDataParameter[] param):连接对象为空!");
return 0;
}
System.Data.IDbCommand cmd = Conn.CreateCommand();
cmd.CommandText = sql;
for(int i=0;i<param.Length;i++)
{
cmd.Parameters.Add(param[i]);
}
try
{
return cmd.ExecuteNonQuery();
}
catch(Exception ex)
{
Common.ErrLog("ClsDB.Execute(string sql,System.Data.IDataParameter[] param):"+ex.Message+"/nsql="+sql);
return 0;
}
}//Execute(string sql,System.Data.IDataParameter[] param)

/// <summary>
/// 执行一个事务
/// </summary>
/// <param name="sqls">Sql语句组</param>
/// <returns>成功时返回true</returns>
static public bool ExecuteTrans(string[] sqls)
{
System.Data.IDbTransaction myTrans;
System.Data.IDbConnection Conn = ClsDB.getConn();
if (Conn == null)
{
Common.ErrLog("ClsDB.ExecuteTrans(string[] sqls):连接对象为空!");
return false;
}
System.Data.IDbCommand cmd = Conn.CreateCommand();
myTrans = Conn.BeginTransaction();
cmd.Transaction = myTrans;
try
{
foreach(string sql in sqls)
{
if(sql !=null)
{
cmd.CommandText=sql;
cmd.ExecuteNonQuery();
}
}
myTrans.Commit();
}
catch(Exception ex)
{
myTrans.Rollback();
Common.ErrLog("ClsDB.ExecuteTrans(string[] sqls):" + ex.Message);
return false;
}
return true;
}//Execute(string sql)


/// <summary>
/// 创建查询参数
/// </summary>
/// <returns>参数</returns>
public static System.Data.IDataParameter CreateParameter()
{
string connType = "";
try
{
connType = ConfigurationManager.ConnectionStrings["ConnectionType"].ToString();
if (connType == null || connType == "")
{
Common.ErrLog("ClsDB.OpenConnect():ConnectionType为空");
}
}
catch (Exception ex)
{
Common.ErrLog(ex.Message);
}
switch (connType.ToLower())
{
case "sqlserver":
return new System.Data.SqlClient.SqlParameter();
//case "oracle":
//return new System.Data.OracleClient.OracleParameter();
case "oledb":
return new System.Data.OleDb.OleDbParameter();
case "odbc":
return new System.Data.Odbc.OdbcParameter();
default:
return new System.Data.Odbc.OdbcParameter();
}
}

}
}

[zhanlinzhangna520]

楼主的功能只要自己写一个类来封装所有要连接的数据库类型，然后使用.net中提供的ado.net控件类中的数据库连接控件连接不同的数据库就可以了，在封装的类中使用一个分支语句不就实现了你的功能。

[呦呦]

学习
............................

[m5230529]

配置文件，然后根据配置文件得

[wangshisen66]

你其实是需要实现数据库操作的工厂类，请查询设计模式之工厂模式

[ILMF111]

[Quote=引用 10 楼 hexiaolong0516 的回复:]
引用 2 楼 bluedoctor 的回复:
如果光是SQL,Oracle,ACESS这三个,可以使用OLEDB驱动方式，如果想要更多，就只有ODBC方式了。


怎么弄，能附个网址么，谢谢
[/Quote]
希望 能 看到源代码