.NET通用访问数据库类（C#版）

最新推荐文章于 2023-04-27 09:00:09 发布
最新推荐文章于 2023-04-27 09:00:09 发布
阅读量2.9k 收藏
点赞数
分类专栏： Oracle/SQL Server C# 文章标签： 数据库 .net c# dataset string exception
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FenceKing/article/details/616496
版权

      在数据库应用程序的开发中，往往一个应用程序要从多个数据库中取得所要的业务数据。对于ADO.NET更是如此，一个DataSet，可能是从几个数据库中取得的数据集合。为此开发一个访问数据库通用接口显得更为方便、灵活。下面是一个针对.NET提供的四种访问数据库的通用类，每个类都有具体实现了一些常用访问数据库的方法。对于UpdateDataSet 方法，要考虑数据更新的并发冲突，就目前还没有一个非常人性的解决办法。不过本人到总结了几个常用解决此问题的方法，在稍后将作为一个专门的话题推出。在这里暂时没有把此源代码贴上，望大家原谅！

DataProvider.cs 此类返回一个访问数据库的接口实例。

#define DEBUG
using System;
namespace FenceKing.DataProviders
{
 /// <summary>
 /// 提供对数据库访问的通用类。
 /// </summary>
 public class DataProvider
 { 
  /// <summary>
  /// 数据库枚举类型
  /// </summary>
  public enum DataProviderType
  {
   OdbcDataProvider = 0,
   OleDbDataProvider = 1,
   OracleDataProvider = 2,
   SqlDataProvider = 3  
  }

  /// <summary>
  /// 建立访问数据库的实例
  /// </summary>
  /// <param name="DataProviderType">数据库枚举类型</param>
  /// <returns></returns>
  public static IDataProvider CreateDataProvider(DataProviderType dataProviderType)
  {
   switch (dataProviderType)
   {
    case DataProviderType.OdbcDataProvider:
     return new OdbcDataProvider();     
    case DataProviderType.OleDbDataProvider:
     return new OleDbDataProvider();   
    case DataProviderType.OracleDataProvider:
     return new OracleDataProvider();     
    case DataProviderType.SqlDataProvider:
     return new SqlDataProvider();     
    default:
#if DEBUG
     System.Diagnostics.Debug.WriteLine("dataProviderType 类型不存在!");
#endif
     return null;
   }
  }

 }
}

 

IDataProvider.cs 访问数据库的接口类。

using System;

namespace FenceKing.DataProviders
{
 /// <summary>
 /// 对数据库访问的通用接口
 /// </summary>
 public interface IDataProvider
 { 
  /// <summary>
  /// 执行 UPDATE、INSERT 和 DELETE 语句，返回值为该命令所影响的行数
  /// </summary>  
  int ExecuteNonQuery(string sql);

  /// <summary>
  /// 执行查询，并将查询返回的结果集中第一行的第一列作为 .NET Framework 数据类型返回。忽略额外的列或行
  /// </summary>  
  object ExecuteScalar(string sql);
  
  /// <summary>
  ///  执行单Sql语句查询，并将查询返回的结果作为一个数据集返回
  /// </summary>  
  System.Data.DataSet RetriveDataSet(string sql); 
  
  /// <summary>
  ///  执行Sql数组语句查询，并将查询返回的结果作为一个数据集返回  
  /// </summary>  
  System.Data.DataSet RetriveDataSet(string[] sql, params string[] tableName);

  /// <summary>
  /// 更新库
  /// </summary>
  /// <param name="sql"></param>
  /// <param name="hasChangesDataSet"></param>
  /// <returns></returns>
  System.Data.DataSet UpdateDataSet(string sql, System.Data.DataSet hasChangesDataSet);

  /// <summary>
  /// 执行Dispose
  /// </summary>
  void Dispose();  
 }
}

OracleDataProvider.cs 访问Oracle的类

#define DEBUG
using System;
using System.Data;
using System.Data.OracleClient;

namespace FenceKing.DataProviders
{
 /// <summary>
 /// OracleDataProvider 的摘要说明。
 /// </summary>
 internal class OracleDataProvider : IDataProvider
 {
  private System.Data.OracleClient.OracleConnection oracleConnection;
  private System.Data.OracleClient.OracleCommand oracleCommand;
  private string connectionString;
  public OracleDataProvider() : this(null)
  {
   //
   // TODO: 在此处添加构造函数逻辑
   //
  }

  public OracleDataProvider(string connectionString)
  { 
   if (connectionString == null || connectionString.Trim() == string.Empty)
   {
    System.Configuration.AppSettingsReader configurationAppSettings = new System.Configuration.AppSettingsReader();
    this.connectionString = (string)(configurationAppSettings.GetValue("oracleConnectionString", typeof(string)));
   }
   else
   { 
    this.connectionString = connectionString;
   }    
  }
  
  /// <summary>
  /// Oracle 连接字符串 "User Id=southfence;Data Source=FENCEORA;Password=southfence;Persist Security Info=true;"    
  /// </summary>
  public string ConnectionString
  {
   get{
    return this.connectionString;
   }
   set{
    this.connectionString = value;
   }
  } 
 
  /// <summary>
  /// 返回一个带有连接字符串的Oracle Connection.
  /// </summary>
  /// <returns>OracleConnection</returns>
  private OracleConnection GetOracleConnection()
  {
   try
   {
//    if (connectionString == null || connectionString.Trim() == string.Empty)
//    {
//
//     System.Configuration.AppSettingsReader configurationAppSettings = new System.Configuration.AppSettingsReader();
//     this.connectionString = ((string)(configurationAppSettings.GetValue("oracleConnectionString", typeof(string))));
//    }
    return new OracleConnection(this.connectionString);
   }
   catch (Exception ex)
   {
#if DEBUG
    System.Diagnostics.Debug.WriteLine(ex.ToString());
#endif
    return null;
   }
  }

  /// <summary>
  /// 对于 UPDATE、INSERT 和 DELETE 语句，返回值为该命令所影响的行数。对于其他所有类型的语句，返回值为 -1
  /// </summary>
  /// <param name="Sql">UPDATE、INSERT 和 DELETE 语句</param>
  public int ExecuteNonQuery(string sql)
  {
   using(oracleConnection = this.GetOracleConnection())
   {
    if (oracleConnection == null)
     return -1;
    int rv = -1;
    OracleTransaction oracleTransaction = null;   
    try
    {
     if (oracleConnection.State == System.Data.ConnectionState.Closed)
      oracleConnection.Open();     
     oracleCommand = new OracleCommand(sql, oracleConnection);    
     oracleTransaction = oracleConnection.BeginTransaction();
     oracleCommand.Transaction = oracleTransaction;
     rv = oracleCommand.ExecuteNonQuery();
     oracleTransaction.Commit();     
    }
    catch (Exception ex)
    {     
#if DEBUG
     System.Diagnostics.Debug.WriteLine(ex.ToString());
#endif
     oracleTransaction.Rollback();
     rv = -1;
    }    

    return rv;
   }
  }

  /// <summary>
  /// 执行查询，并将查询返回的结果集中第一行的第一列作为 .NET Framework 数据类型返回。忽略额外的列或行。
  /// </summary>
  /// <param name="sql">SELECT 语句</param>
  /// <returns>.NET Framework 数据类型形式的结果集第一行的第一列；如果结果集为空或结果为 REF CURSOR，则为空引用</returns>
  public object ExecuteScalar(string sql)
  {   
   using(oracleConnection = this.GetOracleConnection())
   {
    if (oracleConnection == null)
     return null;
    try
    {
     if (oracleConnection.State == System.Data.ConnectionState.Closed)
      oracleConnection.Open();     
     oracleCommand = new OracleCommand(sql, oracleConnection);
     return oracleCommand.ExecuteScalar();
    }
    catch (Exception ex)
    {     
#if DEBUG
     System.Diagnostics.Debug.WriteLine(ex.ToString());
#endif
     return null;
    }    
   }
  }

  /// <summary>
  ///  执行单Sql语句查询，并将查询返回的结果作为一个数据集返回
  /// </summary>
  /// <param name="selectSql">SELECT 语句</param>
  /// <returns>数据集 DataSet</returns>
  public DataSet RetriveDataSet(string sql)
  {   
   if (sql == null || sql == string.Empty)
   {
#if DEBUG
    System.Diagnostics.Debug.WriteLine("sql 为空");    
#endif
    return null;
   }   
   using(oracleConnection = this.GetOracleConnection())
   {  
    if (oracleConnection == null)
     return null;
    using( OracleDataAdapter da = new OracleDataAdapter(sql, oracleConnection))
    {
     DataSet ds = new DataSet();
     try
     {
      da.Fill(ds);
     }     
     catch (Exception ex)
     {
#if DEBUG
      System.Diagnostics.Debug.WriteLine(ex.ToString());
#endif
     }     
     return ds;
    }   
   }   
  } 
 
  /// <summary>
  /// 执行Sql数组语句查询，并将查询返回的结果作为一个数据集返回
  /// </summary>
  /// <param name="sql">Select 语句数组</param>
  /// <param name="tableName">TableName</param>
  /// <returns>数据集 DataSet</returns>
  public DataSet RetriveDataSet(string[] sql, params string[] tableName)
  {
   int sqlLength;   
   sqlLength = sql.Length;
   if ( sqlLength == 0)
   {
#if DEBUG
    System.Diagnostics.Debug.WriteLine("sql 为空");
#endif
    return null;
   } 
   using(oracleConnection = this.GetOracleConnection())
   {  
    if (oracleConnection == null)
     return null;
    DataSet ds = new DataSet();
    int tableNameLength = tableName.Length;
    for (int i = 0; i < sqlLength; i++)
    {
     using(OracleDataAdapter da = new OracleDataAdapter(sql[i], oracleConnection))
     { 
      try
      {       
       if (i < tableNameLength)
        da.Fill(ds, tableName[i]);
       else
        da.Fill(ds, "table" + i);       
      }     
      catch (Exception ex)
      {
#if DEBUG
       System.Diagnostics.Debug.WriteLine(ex.ToString());
#endif
       return null;
      }
     } 
    }
    return ds;  
   }   
  }

  /// <summary>
  /// 更新数据集.
  /// 过程:客户层(dataSet.GetChanges()) -- 修改 --> 数据服务层(hasChangesDataSet.update()) -- 更新--> 数据层(hasChangesDataSet) ...
  ///  数据层(hasChangesDataSet) -- 新数据 --> 数据服务层 (hasChangesDataSet) -- 合并 -- > 客户层(dataSet.Merge(hasChangesDataSet))
  /// </summary>
  /// <param name="hasChangeDataSet"></param>
  /// <returns></returns>
  public DataSet UpdateDataSet(string sql, DataSet hasChangesDataSet)
  {
      
  }

  /// <summary>
  ///  执行Sql数组语句查询，并将查询返回的结果作为一个数据读取器返回
  /// </summary>
  /// <param name="sql"></param>
  /// <returns>OracleDataReader</returns>
  public OracleDataReader RetriveDataReader(string sql)
  {
   if (sql == null || sql == string.Empty)
   {
#if DEBUG
    System.Diagnostics.Debug.WriteLine("sql 为空");    
#endif
    return null;
   }   
   using(oracleConnection = this.GetOracleConnection())
   {  
    if (oracleConnection == null)
     return null;
    using(oracleCommand = new OracleCommand(sql, oracleConnection))
    {   
     try
     {
      OracleDataReader oracleDataReader = oracleCommand.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
      return oracleDataReader;
     }     
     catch (Exception ex)
     {
#if DEBUG
      System.Diagnostics.Debug.WriteLine(ex.ToString());
#endif
      return null;

     }
    } 
   }   
  }

  public void Dispose()
  {
   this.connectionString = null;
   this.oracleCommand.Dispose();
   this.oracleConnection.Dispose();
  }
 }
}

SqlDataProvider.cs 访问SQL Server的类。

#define DEBUG
using System;
using System.Data;
using System.Data.SqlClient;

namespace FenceKing.DataProviders
{
 /// <summary>
 /// SqlDataProvider 的摘要说明。
 /// </summary>
 internal class SqlDataProvider : IDataProvider
 {
  private System.Data.SqlClient.SqlConnection sqlConnection;
  private System.Data.SqlClient.SqlCommand sqlCommand;
  private string connectionString;
  public SqlDataProvider() : this(null)
  {
   //
   // TODO: 在此处添加构造函数逻辑
   //
  }

  public SqlDataProvider(string connectionString)
  { 
   if (connectionString == null || connectionString.Trim() == string.Empty)
   {
    System.Configuration.AppSettingsReader configurationAppSettings = new System.Configuration.AppSettingsReader();
    this.connectionString = (string)(configurationAppSettings.GetValue("sqlConnectionString", typeof(string)));
   }
   else
   { 
    this.connectionString = connectionString;
   }    
  }
  
  /// <summary>
  /// SQL 连接字符串
  /// </summary>
  public string ConnectionString
  {
   get
   {
    return this.connectionString;
   }
   set
   {
    this.connectionString = value;
   }
  } 
 
  /// <summary>
  /// 返回一个带有连接字符串的SQL Connection.
  /// </summary>
  /// <returns>OracleConnection</returns>
  private SqlConnection GetSqlConnection()
  {
   try
   {
//    if (connectionString == null || connectionString.Trim() == string.Empty)
//    {
//     System.Configuration.AppSettingsReader configurationAppSettings = new System.Configuration.AppSettingsReader();
//     this.connectionString = ((string)(configurationAppSettings.GetValue("sqlConnectionString", typeof(string))));
//    }
    return new SqlConnection(this.connectionString);
   }
   catch (Exception ex)
   {
#if DEBUG
    System.Diagnostics.Debug.WriteLine(ex.ToString());
#endif
    return null;
   }
  }

  /// <summary>
  /// 对于 UPDATE、INSERT 和 DELETE 语句，返回值为该命令所影响的行数。对于其他所有类型的语句，返回值为 -1
  /// </summary>
  /// <param name="Sql">UPDATE、INSERT 和 DELETE 语句</param>
  public int ExecuteNonQuery(string sql)
  {
   using(sqlConnection = this.GetSqlConnection())
   {
    if (sqlConnection == null)
     return -1;
    try
    {
     if (sqlConnection.State == System.Data.ConnectionState.Closed)
      sqlConnection.Open();     
     sqlCommand = new SqlCommand(sql, sqlConnection);
     return sqlCommand.ExecuteNonQuery();
    }
    catch (Exception ex)
    {  
#if DEBUG
     System.Diagnostics.Debug.WriteLine(ex.ToString());
#endif  
     return -1;
    }    
   }
  }

  /// <summary>
  /// 执行查询，并将查询返回的结果集中第一行的第一列作为 .NET Framework 数据类型返回。忽略额外的列或行。
  /// </summary>
  /// <param name="sql">SELECT 语句</param>
  /// <returns>.NET Framework 数据类型形式的结果集第一行的第一列；如果结果集为空或结果为 REF CURSOR，则为空引用</returns>
  public object ExecuteScalar(string sql)
  {   
   using(sqlConnection = this.GetSqlConnection())
   {
    if (sqlConnection == null)
     return null;
    try
    {
     if (sqlConnection.State == System.Data.ConnectionState.Closed)
      sqlConnection.Open();     
     sqlCommand = new SqlCommand(sql, sqlConnection);
     return sqlCommand.ExecuteScalar();
    }
    catch (Exception ex)
    { 
#if DEBUG
     System.Diagnostics.Debug.WriteLine(ex.ToString());
#endif 
     return null;
    }    
   }
  }
 
  /// <summary>
  ///  执行单Sql语句查询，并将查询返回的结果作为一个数据集返回
  /// </summary>
  /// <param name="sql">SELECT 语句</param>
  /// <returns>数据集 DataSet</returns> 
  public DataSet RetriveDataSet(string sql)
  {   
   if (sql == null || sql == string.Empty)
   {
#if DEBUG
    System.Diagnostics.Debug.WriteLine("sql 为空"); 
#endif
    return null;
   }   
   using(sqlConnection = this.GetSqlConnection())
   {  
    if (sqlConnection == null)
     return null;
    using(SqlDataAdapter da = new SqlDataAdapter(sql, sqlConnection))
    {
     DataSet ds = new DataSet();
     try
     {
      da.Fill(ds);
     }     
     catch (Exception ex)
     {
#if DEBUG
      System.Diagnostics.Debug.WriteLine(ex.ToString()); 
#endif
     }     
     return ds;
    }   
   }   
  } 
 
  /// <summary>
  /// 执行Sql数组语句查询，并将查询返回的结果作为一个数据集返回
  /// </summary>
  /// <param name="sql">Select 语句数组</param>
  /// <param name="tableName">TableName</param>
  /// <returns>数据集 DataSet</returns>
  public DataSet RetriveDataSet(string[] sql, params string[] tableName)
  {
   int sqlLength;
   sqlLength = sql.Length;
   if ( sqlLength == 0)
   {
#if DEBUG
    System.Diagnostics.Debug.WriteLine("sql 为空");
#endif
    return null;
   }  
   using(sqlConnection = this.GetSqlConnection())
   {  
    if (sqlConnection == null)
     return null;
    DataSet ds = new DataSet();
    int tableNameLength = tableName.Length;
    for (int i = 0; i < sqlLength; i++)
    {
     using(SqlDataAdapter da = new SqlDataAdapter(sql[i], sqlConnection))
     { 
      try
      {      
       if (i < tableNameLength)
        da.Fill(ds, tableName[i]);
       else
        da.Fill(ds, "table" + i);       
      }      
      catch (Exception ex)
      {
#if DEBUG
       System.Diagnostics.Debug.WriteLine(ex.ToString());
#endif
       return null;
      }
     } 
    }
    return ds;  
   }   
  }

  public DataSet UpdateDataSet(string sql, DataSet hasChangesDataSet)
  {
   return null;
  }

  public void Dispose()
  {
   this.connectionString = null;
   this.sqlCommand.Dispose();
   this.sqlConnection.Dispose();
  }

 }
}

OdbcDataProvider.cs 提供ODBC连接访问的类

#define DEBUG
using System;
using System.Data;
using System.Data.Odbc;
namespace FenceKing.DataProviders
{
 /// <summary>
 /// OdbcDataProvider 的摘要说明。
 /// </summary>
 internal class OdbcDataProvider : IDataProvider
 {
  private System.Data.Odbc.OdbcConnection odbcConnection;
  private System.Data.Odbc.OdbcCommand odbcCommand;
  private string connectionString;
  public OdbcDataProvider() : this(null)
  {
   //
   // TODO: 在此处添加构造函数逻辑
   //
  }

  public OdbcDataProvider(string connectionString)
  { 
   if (connectionString == null || connectionString.Trim() == string.Empty)
   {
    System.Configuration.AppSettingsReader configurationAppSettings = new System.Configuration.AppSettingsReader();
    this.connectionString = (string)(configurationAppSettings.GetValue("odbcConnectionString", typeof(string)));
   }
   else
   { 
    this.connectionString = connectionString;
   }    
  }
  
  /// <summary>
  /// Oracle 连接字符串 "User Id=southfence;Data Source=FENCEORA;Password=southfence;Persist Security Info=true;"    
  /// </summary>
  public string ConnectionString
  {
   get
   {
    return this.connectionString;
   }
   set
   {
    this.connectionString = value;
   }
  } 
 
  /// <summary>
  /// 返回一个带有连接字符串的Odbc Connection.
  /// </summary>
  /// <returns>OracleConnection</returns>
  private OdbcConnection GetOdbcConnection()
  {
   try
   {
//    if (connectionString == null || connectionString.Trim() == string.Empty)
//    {
//     System.Configuration.AppSettingsReader configurationAppSettings = new System.Configuration.AppSettingsReader();
//     this.connectionString = ((string)(configurationAppSettings.GetValue("odbcConnectionString", typeof(string))));
//    }
    return new OdbcConnection(this.connectionString);
   }
   catch (Exception ex)
   {
#if DEBUG
    System.Diagnostics.Debug.WriteLine(ex.ToString());
#endif
    return null;
   }
  }

  /// <summary>
  /// 对于 UPDATE、INSERT 和 DELETE 语句，返回值为该命令所影响的行数。对于其他所有类型的语句，返回值为 -1
  /// </summary>
  /// <param name="Sql">UPDATE、INSERT 和 DELETE 语句</param>
  public int ExecuteNonQuery(string sql)
  {
   using(odbcConnection = this.GetOdbcConnection())
   {
    if (odbcConnection == null)
     return -1;
    try
    {
     if (odbcConnection.State == System.Data.ConnectionState.Closed)
      odbcConnection.Open();     
     odbcCommand = new OdbcCommand(sql, odbcConnection);
     return odbcCommand.ExecuteNonQuery();
    }
    catch (Exception ex)
    { 
#if DEBUG
     System.Diagnostics.Debug.WriteLine(ex.ToString());
#endif
     return -1;
    }    
   }
  }

  /// <summary>
  /// 执行查询，并将查询返回的结果集中第一行的第一列作为 .NET Framework 数据类型返回。忽略额外的列或行。
  /// </summary>
  /// <param name="sql">SELECT 语句</param>
  /// <returns>.NET Framework 数据类型形式的结果集第一行的第一列；如果结果集为空或结果为 REF CURSOR，则为空引用</returns>
  public object ExecuteScalar(string sql)
  {   
   using(odbcConnection = this.GetOdbcConnection())
   {
    if (odbcConnection == null)
     return null;
    try
    {
     if (odbcConnection.State == System.Data.ConnectionState.Closed)
      odbcConnection.Open();
     odbcCommand = new OdbcCommand(sql, odbcConnection);
     return odbcCommand.ExecuteScalar();
    }
    catch (Exception ex)
    { 
#if DEBUG
     System.Diagnostics.Debug.WriteLine(ex.ToString());
#endif
     return null;
    }    
   }
  }

  /// <summary>
  ///  执行单Sql语句查询，并将查询返回的结果作为一个数据集返回
  /// </summary>
  /// <param name="selectSql">SELECT 语句</param>
  /// <returns>数据集 DataSet</returns>
  public DataSet RetriveDataSet(string sql)
  {   
   if (sql == null || sql == string.Empty)
   {
#if DEBUG
    System.Diagnostics.Debug.WriteLine("sql 为空");    
#endif
    return null;
   }   
   using(odbcConnection = this.GetOdbcConnection())
   {  
    if (odbcConnection == null)
     return null;
    using( OdbcDataAdapter da = new OdbcDataAdapter(sql, odbcConnection))
    {
     DataSet ds = new DataSet();
     try
     {
      da.Fill(ds);
     }     
     catch (Exception ex)
     {
#if DEBUG
      System.Diagnostics.Debug.WriteLine(ex.ToString());
#endif
      return null;
     }     
     return ds;
    }   
   }   
  }

 
  /// <summary>
  /// 执行Sql数组语句查询，并将查询返回的结果作为一个数据集返回
  /// </summary>
  /// <param name="sql">Select 语句数组</param>
  /// <param name="tableName">TableName</param>
  /// <returns>数据集 DataSet</returns>
  public DataSet RetriveDataSet(string[] sql, params string[] tableName)
  {
   int sqlLength;
   sqlLength = sql.Length;
   if ( sqlLength == 0)
   {
#if DEBUG
    System.Diagnostics.Debug.WriteLine("sql 为空");
#endif
    return null;
   }  
   using(odbcConnection = this.GetOdbcConnection())
   {  
    if (odbcConnection == null)
     return null;
    DataSet ds = new DataSet();
    int tableNameLength = tableName.Length;
    for (int i = 0; i < sqlLength; i++)
    {
     using(OdbcDataAdapter da = new OdbcDataAdapter(sql[i], odbcConnection))
     { 
      try
      { 
       if (i < tableNameLength)
        da.Fill(ds, tableName[i]);
       else
        da.Fill(ds, "table" + i);      
      }      
      catch (Exception ex)
      {
#if DEBUG
       System.Diagnostics.Debug.WriteLine(ex.ToString());
#endif
      }
     } 
    }
    return ds;  
   }   
  }

  public DataSet UpdateDataSet(string sql, DataSet hasChangesDataSet)
  {
   return null;
  }


  public void Dispose()
  {
   this.connectionString = null;
   this.odbcCommand.Dispose();
   this.odbcConnection.Dispose();   
  }
 }
}

OleDbDataProvider.cs 提供OLEDB连接访问的类。

#define DEBUG
using System;
using System.Data;
using System.Data.OleDb;

namespace FenceKing.DataProviders
{
 /// <summary>
 /// OleDbDataProvider 的摘要说明。
 /// </summary>
 internal class OleDbDataProvider : IDataProvider
 {
  
  private System.Data.OleDb.OleDbConnection oleDbConnection;
  private System.Data.OleDb.OleDbCommand oleDbCommand;
  private string connectionString;
  public OleDbDataProvider() : this(null)
  {
   //
   // TODO: 在此处添加构造函数逻辑
   //
  }  
 
  public OleDbDataProvider(string connectionString)
  { 
   if (connectionString == null || connectionString.Trim() == string.Empty)
   {
    System.Configuration.AppSettingsReader configurationAppSettings = new System.Configuration.AppSettingsReader();
    this.connectionString = (string)(configurationAppSettings.GetValue("oleDbConnectionString", typeof(string)));
   }
   else
   { 
    this.connectionString = connectionString;
   }    
  }
  
  /// <summary>
  /// OleDb 连接字符串
  /// </summary>
  public string ConnectionString
  {
   get
   {
    return this.connectionString;
   }
   set
   {
    this.connectionString = value;
   }
  } 
 
  /// <summary>
  /// 返回一个带有连接字符串的OleDb Connection.
  /// </summary>
  /// <returns>OracleConnection</returns>
  private OleDbConnection GetOleDbConnection()
  {
   try
   {
//    if (connectionString == null || connectionString.Trim() == string.Empty)
//    {
//     System.Configuration.AppSettingsReader configurationAppSettings = new System.Configuration.AppSettingsReader();
//     this.connectionString = ((string)(configurationAppSettings.GetValue("oleDbConnectionString", typeof(string))));
//    }
    return new OleDbConnection(this.connectionString);
   }
   catch (Exception ex)
   {
#if DEBUG
    System.Diagnostics.Debug.WriteLine(ex.ToString());
#endif
    return null;
   }
  }

  /// <summary>
  /// 对于 UPDATE、INSERT 和 DELETE 语句，返回值为该命令所影响的行数。对于其他所有类型的语句，返回值为 -1
  /// </summary>
  /// <param name="Sql">UPDATE、INSERT 和 DELETE 语句</param>
  public int ExecuteNonQuery(string sql)
  {
   using(oleDbConnection = this.GetOleDbConnection())
   {
    if (oleDbConnection == null)
     return -1;
    try
    {
     if (oleDbConnection.State == System.Data.ConnectionState.Closed)
      oleDbConnection.Open();     
     oleDbCommand = new OleDbCommand(sql, oleDbConnection);
     return oleDbCommand.ExecuteNonQuery();
    }
    catch (Exception ex)
    {     
#if DEBUG
     System.Diagnostics.Debug.WriteLine(ex.ToString());
#endif
     return -1;
    }    
   }
  }

  /// <summary>
  /// 执行查询，并将查询返回的结果集中第一行的第一列作为 .NET Framework 数据类型返回。忽略额外的列或行。
  /// </summary>
  /// <param name="sql">SELECT 语句</param>
  /// <returns>.NET Framework 数据类型形式的结果集第一行的第一列；如果结果集为空或结果为 REF CURSOR，则为空引用</returns>
  public object ExecuteScalar(string sql)
  {   
   using(oleDbConnection = this.GetOleDbConnection())
   {
    if (oleDbConnection == null)
     return null;
    try
    {
     if (oleDbConnection.State == System.Data.ConnectionState.Closed)
      oleDbConnection.Open();     
     oleDbCommand = new OleDbCommand(sql, oleDbConnection);
     return oleDbCommand.ExecuteScalar();
    }
    catch (Exception ex)
    {     
#if DEBUG
     System.Diagnostics.Debug.WriteLine(ex.ToString());
#endif
     return null;
    }    
   }
  }

  /// <summary>
  ///  执行单Sql语句查询，并将查询返回的结果作为一个数据集返回
  /// </summary>
  /// <param name="selectSql">SELECT 语句</param>
  /// <returns>数据集 DataSet</returns>
  public DataSet RetriveDataSet(string sql)
  {   
   if (sql == null || sql == string.Empty)
   {
#if DEBUG
    System.Diagnostics.Debug.WriteLine("sql 为空");    
#endif
    return null;
   }   
   using(oleDbConnection = this.GetOleDbConnection())
   {  
    if (oleDbConnection == null)
     return null;
    using(OleDbDataAdapter da = new OleDbDataAdapter(sql, oleDbConnection))
    {
     DataSet ds = new DataSet();
     try
     {
      da.Fill(ds);
     }     
     catch (Exception ex)
     {
#if DEBUG
      System.Diagnostics.Debug.WriteLine(ex.ToString());
#endif
     }     
     return ds;
    }   
   }   
  }

 
  /// <summary>
  /// 执行Sql数组语句查询，并将查询返回的结果作为一个数据集返回
  /// </summary>
  /// <param name="sql">Select 语句数组</param>
  /// <param name="tableName">TableName</param>
  /// <returns>数据集 DataSet</returns>
  public DataSet RetriveDataSet(string[] sql, params string[] tableName)
  {
   int sqlLength;
   sqlLength = sql.Length;
   if ( sqlLength == 0)
   {
#if DEBUG
    System.Diagnostics.Debug.WriteLine("sql 为空");
#endif
    return null;
   }  
   using(oleDbConnection = this.GetOleDbConnection())
   {  
    if (oleDbConnection == null)
     return null;
    DataSet ds = new DataSet();
    int tableNameLength = tableName.Length;
    for (int i = 0; i < sqlLength; i++)
    {
     using(OleDbDataAdapter da = new OleDbDataAdapter(sql[i], oleDbConnection))
     { 
      try
      { 
       if (i < tableNameLength)
        da.Fill(ds, tableName[i]);
       else
        da.Fill(ds, "table" + i);       
      }     
      catch (Exception ex)
      {
#if DEBUG
       System.Diagnostics.Debug.WriteLine(ex.ToString());
#endif
       return null;
      }
     } 
    }
    return ds;  
   }   
  }

  public DataSet UpdateDataSet(string sql, DataSet hasChangesDataSet)
  {
   return null;
  }

  public void Dispose()
  {
   this.connectionString = null;
   this.oleDbCommand.Dispose();
   this.oleDbConnection.Dispose();
  }
 }
}

App.config 应用程序配置文件。

<?xml version="1.0" encoding="utf-8"?>
<configuration>
 <appSettings>
  <!--   此处显示用户应用程序和配置的属性设置。-->
  <!--   示例：<add key="settingName" value="settingValue"/> -->
  <!-- 连接数据库的字符串 -->
  <add key="oracleConnectionString" value="User Id=southfence;Data Source=FENCEORA;Password=southfence;Persist Security Info=true;" />
  <add key="sqlConnectionString" value="workstation id=FENCEKING;packet size=4096;integrated security=SSPI;data source=&quot;FENCEKING/FENCESQL&quot;;persist security info=True;initial catalog=Northwind" />
  <add key="oleDbConnectionString" value="" />
  <add key="odbcConnectionString" value="" />
 </appSettings>
</configuration>

FenceKingTest 客户测试

public FenceKingTest()
  {
   //
   // Windows 窗体设计器支持所必需的
   //
   InitializeComponent();

   //
   // TODO: 在 InitializeComponent 调用后添加任何构造函数代码
   //   

// 声明一个接口，返回一个访问SQL Server的数据库实例
   FenceKing.DataProviders.IDataProvider sqlDataProvider = FenceKing.DataProviders.DataProvider.CreateDataProvider(DataProvider.DataProviderType.SqlDataProvider);
   string[] sql = new string[2];
   sql[0] = "SELECT * FROM Orders";
   sql[1] = "SELECT CustomerID, CompanyName, ContactName FROM Customers";  
   DataSet ds;
   string[] tableName = new string[]{"Orders","Customers"};   
   ds = sqlDataProvider.RetriveDataSet(sql, tableName);
   ds.Relations.Add("CustomerOrders",ds.Tables["Customers"].Columns["CustomerID"],ds.Tables["Orders"].Columns["CustomerID"]);
   this.dataGrid1.SetDataBinding(ds, ds.Tables[1].TableName); 
  }

FenceKing
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C#.NET万能数据库访问封装类(ACCESS、SQLServer、Oracle)
01-10
C#.NET万能数据库访问封装类(ACCESS、SQLServer、Oracle) 这个类封装成dll后，相关数据库连接可在，引用该dll项目的app.config文件中写，如果是web程序，这需要修改代码，将构造函数中获取app.config的信息换成获取web.config的信息。
C#通用的数据库操作类(支持多种数据库)
DavidLiu的博客
06-30 8956
通用的数据库操作类(支持多种数据库) 我们在软件开发过程中,数据库是一个永久不变的话题,但是根据软件架构与客户要求的不同我们会选择不同的数据库,在C#中不同数据库操作编写代码不尽相同,下面提供一种通用的数据库操作方案,只需要根据config的配置就可以动态的选择不同的数据库. using System; using System.Collections; using System...
使用C#打造通用的数据库连接类
sakabi的专栏
08-19 1633
<br />众所周知vs.net提供了sqlserver、oledb、odbc等几种数据库连接驱动，现在比较常见的数据库连接类(如DBHelper等)只提供了其中一种连接方式，在我们开发的项目要更换数据库时或者在一个项目中要涉及多个不同类型的数据库时是非常麻烦的，通常要更改几乎所有的数据库连接相关代码。在经过几次痛苦之后，我决定打造一个通用的数据库连接类。<br />在查阅了相关资料之后我决定使用接口技术和.Net最新提供的通用数据库对象和配置文件来实现。关于使用接口技术，在查阅了MSDN文档之后我们得知.
C#-继承IDbConnection连接不同数据库,通用的DbHelper（1）
Aiken的自由世界
01-13 4761
C#-继承IDbConnection连接不同数据库,通用的DbHelper（1） 本方案可实现仅修改app.config即可连接不同数据库，但是设计数据库时需要注意各种数据库的数据类型是不一样的。 各种不同数据库的Connection、Command、DataAdapter、Transaction和Parameter都继承自IDbConnection、IDbCommand、IDbDa
C#封装数据库连接类
listennerBGM的博客
02-22 1341
程序对数据库的增删改查是一个业务的核心,频繁读写数据库是很正常的事情,所以封装出一个数据库连接对象,方便到一行代码直接得到DataTable或DataSet对象就是非常有必要的了,下面给出数据库连接类,数据库连接字符串一般会放在Web.config或App.config配置文件中,Web.config是B/S模式使用的,App.config一般是桌面应用程序使用的,后面也会给出相关的配置文件的写法 App.config <?xml version="1.0" encoding="utf-8" ?&gt
c# .net 通用sql数据库访问的类
06-10
c# .net 通用sql数据库访问的类 比较全，有注释
通用.NET数据库访问类
10-22
根据接口实现访问数据库访问类。c#代码，免费赠送、别扔砖头就行
asp.net 通用的连接数据库实例代码
01-01
<center><h2>”宋体”>访问数据库的通用代码实例</font></h2></center><body> <form id=”form1″ runat=”server”>   ”宋体”>”center”>1.请输入相应数据库连接字符串</p><p align=”center”>&...
Asp.net通用自定义数据库访问类的设计和实现
09-14
针对研究生管理工作信息量大，更新速度快的特点，研究并设计了研究生信息管理系统，该系统采用三层B／S模式结构，基于ASP．NET技术。本文对系统设计中的相关关键技术进行了探讨
asp.net通用数据库访问层源码
09-14
C#通用数据库访问层源码,通用数据库访问层源码,通用数据库访问层源码通用数据库访问层源码,通用数据库访问层源码
C#通用数据库访问类 常用6种数据库VS2008
06-27
通用数据库访问类 通过配置 可实现不同数据库的的访问&def目前实现了SQLserver&def Oracle&def DataAccess <!----> <!----> <!----> <!----> 调用: IDBOperator idb = DBOperator.GetInstance(); string sqlAccess = @"SELECT * FROM Orders"; DataTable dt = idb.ReturnDataTable(sqlAccess);
C#官方通用类库及通用数据库类库
03-10
1. 通用类库 DC.CommonLiteLib针对一些常用算法，线程管理，IO控制，以及ConvertHelper类型转换，StringHelper字符串封装，FileHelper 文件操作封装等，另有CHM官方文件解释用法。 2. 用数据库类库 DC.CommonDbLiteLib针对SqlServer，MySQL，SQLite，Oracle，ODBC，OleDb，Firebird，PostgreSql，DB2，Informix，SqlServerCe连接进行了封装，一般情况下只需要调用一个IDatabaseInfo接口即可使用，而且切换数据库，除了数据库本般的语句规范外，另有CHM官方文件解释用法。
c 封装 oracle数据库封装,C#.NET万能数据库访问封装类(ACCESS、SQLServer、Oracle)
weixin_36199877的博客
04-10 405
在app.config文件中写上数据库中连接信息：app.config文件中代码解析：小注：同理web程序，可以把数据库连接信息放到web.config中。C#.NET万能数据库访问封装类代码如下：(该代码来自百度文库，非自己编写)using System;using System.Linq;using System.Text;using System.Collections;using Syst...
C#通用数据库类
cyj19731210的博客
04-01 1405
C#通用数据库类最近在写一个c#的桌面应用，在网上查了半天，也没有合适的数据库访问类，于是自己动手写的一个，以下是关于该类的简单介绍 1、利用DbProviderFactory创建相应的conntion、command、transaction来实现相应的功能，含参数化查询，添加、更新、删除等功能 2、类默认为Sql server数据库，通过传入数据库文件路径，根据文件扩展名来确定数据库类型，用相应的SqlClientFactory.Instance，或OleDbFactory.Instance，创建dbFa
C# 如何实现支持多种数据库
大佬的博客
04-27 723
以上代码中，定义了一个 IDatabaseHelper 接口，包含打开数据库连接、关闭数据库连接、执行查询等操作。然后，分别实现了 SqlServerHelper 和 MySqlHelper 类，用于支持SQL Server和MySQL的操作。为了实现一个支持多种数据库的操作类，建议采用面向对象编程的思想，将不同的数据库类型封装成独立的类，并提供一致的接口进行调用。在具体使用时，可以根据需要选择相应的数据库类型，并将其实例化为IDatabaseHelper接口，以便在程序中调用通用的方法。
C# 数据库通用类
唐家麦兜
06-11 1178
通用类 using System; using System.Collections.Generic; using System.Data; using System.Data.Common; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ESRTools { /// &lt...
C#连接4种类型数据库（Access、SQL Server、Oracle、MySQL）
阳光岛主的专栏
08-01 813
1、C#连接连接Accessusing System.Data; using System.Data.OleDb; string strConnection="Provider=Microsoft.Jet.OleDb.4.0;"; strConnection +=@"Data Source=C:/BegASPNET/Northwind.mdb"; OleDbConnection objCo
C# 连接SQL Server数据库的几种方式--server+data source等方式
热门推荐
jCuckoo的专栏
10-11 6万+
如何使用Connection对象连接数据库？ 对于不同的.NET数据提供者，ADO.NET采用不同的Connection对象连接数据库。这些Connection对象为我们屏蔽了具体的实现细节，并提供了一种统一的实现方法。 Connection类有四种：SqlConnectio
C#实现mysql数据库连接
qq_53850212的博客
05-26 7705
C#实现mysql数据库连接 目录C#实现mysql数据库连接一、功能实现二、相关驱动下载三、具体功能实现1.连接数据库2.简单CRUD实现1.窗体显示2.相关代码全局变量定义相关控件代码1.“数据库连接”控件2.“查询”控件3."增加"控件4.“删除”控件5."修改"控件 一、功能实现 1、设计一个项目连接到自己的MySQL数据库，数据库包含至少三张表； 2、使用dataGridView控件显示表中的数据； 3、实现基本crud操作； 二、相关驱动下载 mysql-connector-odbc-8.0
C# asp.net
最新发布
09-14
C# 是一种通用的编程语言，而 ASP.NET 是一个用于构建 Web 应用程序的开发框架。ASP.NET 使用 C# 作为主要的编程语言来开发动态网页和 Web 应用程序。通过使用 ASP.NET，开发人员可以轻松地构建可扩展、高性能和安全...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值