Mobile Menu Will Come Here.
隐藏
柏港 ORM

AdoHelper支持多数据库操作的封装(1)

发布：2014/9/25 16:34:43作者：管理员 来源：本站 浏览次数：1823

自己动手写ORM框架系列

自己动手写ORM框架（一）：目标效果预览

自己动手写ORM框架(二):AdoHelper支持多数据库操作的封装(1)

在第二章，主要是底层的针对于数据库的CRUD，包括对于不同类型数据库的可扩展性。

第一步：编写AdoHelper类，用于封装对数据库的操作，能同时支持多个数据库(目前支持SqlServer、Oracle、Access)，可扩展支持任何类型的数据库。

下面先进行代码片段分析，分析完毕后将贴出完整代码，代码块1-1： 

using System; using System.Collections; using System.Collections.Generic; using System.Configuration; using System.Text; using System.Data; using System.Data.Common; using System.Data.SqlClient; using System.Data.OracleClient; using System.Orm.Common; namespace System.Orm.DBUtility
{ public class AdoHelper { //获取数据库类型 private static string strDbType = CommonUtils.GetConfigValueByKey("dbType").ToUpper(); //将数据库类型转换成枚举类型 public static DatabaseType DbType = DatabaseTypeEnumParse<DatabaseType>(strDbType); 
 
 //获取数据库连接字符串 public static string ConnectionString = GetConnectionString("connectionString"); //获取数据库命名参数符号，比如@(SQLSERVER)、:(ORACLE) public static string DbParmChar = DbFactory.CreateDbParmCharacter();
 

(剖析Step1 Begin）==================================================

    代码块1-1中private static string strDbType = CommonUtils.GetConfigValueByKey("dbType").ToUpper();使用到了CommonUtils.GetConfigValueByKey方法，通过读取传入的dbType字符串，到web.config配置文件中取出所配置的数据库类型，配置文件代码块1-2： 

<?xml version="1.0"?> <configuration> <appSettings> <add key="dbType" value="oracle"/> <add key="connectionString" value="DataSource=test;UserID=test;Password=123"/> </appSettings> <system.web>  <compilation debug="true">  </compilation>  <authentication mode="Windows"/> </system.web> </configuration>

下面是CommonUtils.GetConfigValueByKey方法的实现代码块1-3： 

using System; using System.Collections.Generic; using System.Text; using System.Configuration; using System.Reflection; namespace System.Orm.Common
{ public class CommonUtils { // <summary> // 根据传入的Key获取配置文件中的Value值 // </summary> // <param name="Key"></param> // <returns></returns> public static string GetConfigValueByKey(string Key)
        { try { return ConfigurationManager.AppSettings[Key].ToString();
            } catch { throw new Exception("web.config中 Key=\"" + Key + "\"未配置或配置错误！");
            }
        }

(剖析Step1 End）==================================================

(剖析Step2 Begin）==================================================

    代码块1-1中public static DatabaseType DbType = DatabaseTypeEnumParse<DatabaseType>(strDbType);

这段代码是将在配置文件中取到的数据库类型字符串(比如：oracle)转换成已经定义的枚举类型，这里转换为DatabaseType枚举，DatabaseType代码块1-4： 

using System; using System.Collections.Generic; using System.Text; namespace System.Orm.DBUtility
{ // <summary> // 数据库类型枚举，需要扩展类型可在此添加 // </summary> public enum DatabaseType {
        SQLSERVER,
        ORACLE,
        ACCESS,
        MYSQL
    }
}


然后分析如何将字符串转换成枚举类型，用到DatabaseTypeEnumParse这个方法，代码块1-5： 

        // <summary> // 用于数据库类型的字符串枚举转换 // </summary> // <typeparam name="T"></typeparam> // <param name="value"></param> // <returns></returns> public static T DatabaseTypeEnumParse<T>(string value)
        { try { return CommonUtils.EnumParse<T>(value);
            } catch { throw new Exception("数据库类型\"" + value + "\"错误，请检查！");
            }
        }

这里实现枚举转换的功能来自CommonUtils.EnumParse<T>(value);代码块1-6： 

        // <summary> // 用于字符串和枚举类型的转换 // </summary> // <typeparam name="T"></typeparam> // <param name="value"></param> // <returns></returns> public static T EnumParse<T>(string value)
        { try { return (T)Enum.Parse(typeof(T), value);
            } catch { throw new Exception("传入的值与枚举值不匹配。");
            }
        }

上面代码是泛型的使用，在之前应用中：

DatabaseType DbType = DatabaseTypeEnumParse<DatabaseType(strDbType);  

    传入的DatabaseType枚举是这里的泛型T，传入的strDbType是这里的value，通过web.config中配置，

以及private static string strDbType = CommonUtils.GetConfigValueByKey("dbType").ToUpper();,

我们可以得到strDbType=”ORACLE”;

然后回到代码块1-6中：return (T)Enum.Parse(typeof(T), value);

typeof(T)是得到枚举DatabaseType的类型，value是ORACLE,那么这里可以得到：

return (DatabaseType)Enum.Parse(typeof(DatabaseType), ”ORACLE”);

    这样最后我们可以得到DatabaseType DbType = DatabaseTypeEnumParse<DatabaseType>(strDbType); 中DbType的值为DatabaseType.ORACLE,下面是这里在AdoHelper类中定义的DbType公有成员的用法： 

        // <summary> // 根据配置文件中所配置的数据库类型和传入的 // 数据库链接字符串来创建相应数据库连接对象 // </summary> // <param name="connectionString"></param> // <returns></returns> public static IDbConnection CreateDbConnection(string connectionString)
        { IDbConnection conn = null; switch (AdoHelper.DbType)
            { case DatabaseType.SQLSERVER:
                    conn = new SqlConnection(connectionString); break; case DatabaseType.ORACLE:
                    conn = new OracleConnection(connectionString); break; case DatabaseType.ACCESS:
                    conn = new OleDbConnection(connectionString); break; default: throw new Exception("数据库类型目前不支持！");
            } return conn;
        }

(剖析Step2 End）==================================================

(剖析Step3 Begin）==================================================

    代码块1-1中public static string ConnectionString = GetConnectionString("connectionString"); 中通过GetConnectionString(string Key)方法在web.config配置文件中获取数据库连接字符串，配置文件中配置查看代码块1-2，GetConnectionString方法代码块1-7： 

        // <summary> // 根据传入的Key获取配置文件中 // 相应Key的数据库连接字符串 // </summary> // <param name="Key"></param> // <returns></returns> public static string GetConnectionString(string Key)
        { try { return CommonUtils.GetConfigValueByKey(Key);
            } catch { throw new Exception("web.config文件appSettings中数据库连接字符串未配置或配置错误，必须为Key=\"connectionString\"");
            }
        }

 

(剖析Step3 End）==================================================

这里对代码块1-1已经剖析完毕，AdoHelper类中更多的代码剖析将在后面章节中相继完成。

下面是AdoHelper类的完整代码代码如下：

[csharp] view plaincopy
  1. using System;  
  2. using System.Collections;  
  3. using System.Collections.Generic;  
  4. using System.Configuration;  
  5. using System.Text;  
  6. using System.Data;  
  7. using System.Data.Common;  
  8. using System.Data.SqlClient;  
  9. using System.Data.OracleClient;  
  10. using System.Orm.Common;  
  11.   
  12. namespace System.Orm.DBUtility  
  13. {  
  14.     public class AdoHelper  
  15.     {  
  16.        //获取数据库类型  
  17.         private static string strDbType = CommonUtils.GetConfigValueByKey("dbType").ToUpper();  
  18.   
  19.        //将数据库类型转换成枚举类型  
  20.         public static DatabaseType DbType = DatabaseTypeEnumParse<DatabaseType>(strDbType);         
  21.   
  22.        //获取数据库连接字符串  
  23.         public static string ConnectionString = GetConnectionString("connectionString");  
  24.   
  25.         public static string DbParmChar = DbFactory.CreateDbParmCharacter();  
  26.           
  27.         private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable());  
  28.   
  29.         /// <summary>  
  30.         ///通过提供的参数，执行无结果集的数据库操作命令  
  31.         /// 并返回执行数据库操作所影响的行数。  
  32.         /// </summary>  
  33.         /// <param name="connectionString">数据库连接字符串</param>  
  34.         /// <param name="commandType">执行命令的类型（存储过程或T-SQL，等等）</param>  
  35.         /// <param name="commandText">存储过程名称或者T-SQL命令行<</param>  
  36.         /// <param name="commandParameters">执行命令所需的参数数组</param>  
  37.         /// <returns>返回通过执行命令所影响的行数</returns>  
  38.         public static int ExecuteNonQuery(string connectionString, CommandType cmdType, string cmdText, params IDbDataParameter[] commandParameters)  
  39.         {  
  40.             IDbCommand cmd = DbFactory.CreateDbCommand();  
  41.   
  42.             using (IDbConnection conn = DbFactory.CreateDbConnection(connectionString))  
  43.             {  
  44.                 PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);  
  45.                 int val = cmd.ExecuteNonQuery();  
  46.                 cmd.Parameters.Clear();  
  47.                 return val;  
  48.             }  
  49.         }  
  50.         /// <summary>  
  51.         ///通过提供的参数，执行无结果集的数据库操作命令  
  52.         /// 并返回执行数据库操作所影响的行数。  
  53.         /// </summary>  
  54.         /// <param name="connectionString">数据库连接字符串</param>  
  55.         /// <param name="commandType">执行命令的类型（存储过程或T-SQL，等等）</param>  
  56.         /// <param name="commandText">存储过程名称或者T-SQL命令行<</param>  
  57.         /// <returns>返回通过执行命令所影响的行数</returns>  
  58.         public static int ExecuteNonQuery(string connectionString, CommandType cmdType, string cmdText)  
  59.         {  
  60.             IDbCommand cmd = DbFactory.CreateDbCommand();  
  61.   
  62.             using (IDbConnection conn = DbFactory.CreateDbConnection(connectionString))  
  63.             {  
  64.                 PrepareCommand(cmd, conn, null, cmdType, cmdText, null);  
  65.                 int val = cmd.ExecuteNonQuery();  
  66.                 cmd.Parameters.Clear();  
  67.                 return val;  
  68.             }  
  69.         }  
  70.   
  71.         /// <summary>  
  72.         ///通过提供的参数，执行无结果集返回的数据库操作命令  
  73.         ///并返回执行数据库操作所影响的行数。  
  74.         /// </summary>  
  75.         /// <remarks>  
  76.         /// e.g.:    
  77.         ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));  
  78.         /// </remarks>  
  79.         /// <param name="conn">数据库连接对象</param>  
  80.         /// <param name="commandType">执行命令的类型（存储过程或T-SQL，等等）</param>  
  81.         /// <param name="commandText">存储过程名称或者T-SQL命令行</param>  
  82.         /// <param name="commandParameters">执行命令所需的参数数组</param>  
  83.         /// <returns>返回通过执行命令所影响的行数</returns>  
  84.         public static int ExecuteNonQuery(IDbConnection connection, CommandType cmdType, string cmdText, params IDbDataParameter[] commandParameters)  
  85.         {  
  86.             IDbCommand cmd = DbFactory.CreateDbCommand();  
  87.   
  88.             PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);  
  89.             int val = cmd.ExecuteNonQuery();  
  90.             cmd.Parameters.Clear();  
  91.             return val;  
  92.         }  
  93.         /// <summary>  
  94.         ///通过提供的参数，执行无结果集返回的数据库操作命令  
  95.         ///并返回执行数据库操作所影响的行数。  
  96.         /// </summary>  
  97.         /// <remarks>  
  98.         /// e.g.:    
  99.         ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));  
  100.         /// </remarks>  
  101.         /// <param name="conn">数据库连接对象</param>  
  102.         /// <param name="commandType">执行命令的类型（存储过程或T-SQL，等等）</param>  
  103.         /// <param name="commandText">存储过程名称或者T-SQL命令行</param>  
  104.         /// <returns>返回通过执行命令所影响的行数</returns>  
  105.         public static int ExecuteNonQuery(IDbConnection connection, CommandType cmdType, string cmdText)  
  106.         {  
  107.             IDbCommand cmd = DbFactory.CreateDbCommand();  
  108.   
  109.             PrepareCommand(cmd, connection, null, cmdType, cmdText, null);  
  110.             int val = cmd.ExecuteNonQuery();  
  111.             cmd.Parameters.Clear();  
  112.             return val;  
  113.         }  
  114.   
  115.         /// <summary>  
  116.         ///通过提供的参数，执行无结果集返回的数据库操作命令  
  117.         ///并返回执行数据库操作所影响的行数。  
  118.         /// </summary>  
  119.         /// <remarks>  
  120.         /// e.g.:    
  121.         ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));  
  122.         /// </remarks>  
  123.         /// <param name="trans">sql事务对象</param>  
  124.         /// <param name="commandType">执行命令的类型（存储过程或T-SQL，等等）</param>  
  125.         /// <param name="commandText">存储过程名称或者T-SQL命令行<</param>  
  126.         /// <param name="commandParameters">执行命令所需的参数数组</param>  
  127.         /// <returns>返回通过执行命令所影响的行数</returns>  
  128.         public static int ExecuteNonQuery(IDbTransaction trans, CommandType cmdType, string cmdText, params IDbDataParameter[] commandParameters)  
  129.         {  
  130.             IDbConnection conn = null;  
  131.             if (trans == null)  
  132.             {  
  133.                 conn = DbFactory.CreateDbConnection(ConnectionString);  
  134.             }  
  135.             else   
  136.             {  
  137.                 conn = trans.Connection;  
  138.             }  
  139.   
  140.             IDbCommand cmd = DbFactory.CreateDbCommand();  
  141.             PrepareCommand(cmd, conn, trans, cmdType, cmdText, commandParameters);  
  142.             int val = cmd.ExecuteNonQuery();  
  143.             cmd.Parameters.Clear();  
  144.             return val;  
  145.         }  
  146.         /// <summary>  
  147.         ///通过提供的参数，执行无结果集返回的数据库操作命令  
  148.         ///并返回执行数据库操作所影响的行数。  
  149.         /// </summary>  
  150.         /// <remarks>  
  151.         /// e.g.:    
  152.         ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));  
  153.         /// </remarks>  
  154.         /// <param name="trans">sql事务对象</param>  
  155.         /// <param name="commandType">执行命令的类型（存储过程或T-SQL，等等）</param>  
  156.         /// <param name="commandText">存储过程名称或者T-SQL命令行<</param>  
  157.         /// <returns>返回通过执行命令所影响的行数</returns>  
  158.         public static int ExecuteNonQuery(IDbTransaction trans, CommandType cmdType, string cmdText)  
  159.         {  
  160.             IDbCommand cmd = DbFactory.CreateDbCommand();  
  161.             PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, null);  
  162.             int val = cmd.ExecuteNonQuery();  
  163.             cmd.Parameters.Clear();  
  164.             return val;  
  165.         }  
  166.         /// <summary>  
  167.         /// 使用提供的参数，执行有结果集返回的数据库操作命令  
  168.         /// 并返回SqlDataReader对象  
  169.         /// </summary>  
  170.         /// <remarks>  
  171.         /// e.g.:    
  172.         ///  SqlDataReader r = ExecuteReader(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));  
  173.         /// </remarks>  
  174.         /// <param name="connectionString">数据库连接字符串</param>  
  175.         /// <param name="commandType">执行命令的类型（存储过程或T-SQL，等等）</param>  
  176.         /// <param name="commandText">存储过程名称或者T-SQL命令行<</param>  
  177.         /// <param name="commandParameters">执行命令所需的参数数组</param>  
  178.         /// <returns>返回SqlDataReader对象</returns>  
  179.         public static IDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText, params IDbDataParameter[] commandParameters)  
  180.         {  
  181.             IDbCommand cmd = DbFactory.CreateDbCommand();  
  182.             IDbConnection conn = DbFactory.CreateDbConnection(connectionString);  
  183.   
  184.             //我们在这里使用一个 try/catch,因为如果PrepareCommand方法抛出一个异常，我们想在捕获代码里面关闭  
  185.             //connection连接对象，因为异常发生datareader将不会存在，所以commandBehaviour.CloseConnection  
  186.             //将不会执行。  
  187.             try  
  188.             {  
  189.                 PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);  
  190.                 IDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);  
  191.                 cmd.Parameters.Clear();  
  192.                 return rdr;  
  193.             }  
  194.             catch  
  195.             {  
  196.                 conn.Close();  
  197.                 throw;  
  198.             }  
  199.         }  
  200.         /// <summary>  
  201.         ///使用提供的参数，执行有结果集返回的数据库操作命令  
  202.         /// 并返回SqlDataReader对象  
  203.         /// </summary>  
  204.         /// <param name="connectionString">数据库连接字符串</param>  
  205.         /// <param name="commandType">执行命令的类型（存储过程或T-SQL，等等）</param>  
  206.         /// <param name="commandText">存储过程名称或者T-SQL命令行<</param>  
  207.         /// <returns>返回SqlDataReader对象</returns>  
  208.         public static IDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText)  
  209.         {  
  210.             IDbCommand cmd = DbFactory.CreateDbCommand();  
  211.             IDbConnection conn = DbFactory.CreateDbConnection(connectionString);  
  212.   
  213.             //我们在这里使用一个 try/catch,因为如果PrepareCommand方法抛出一个异常，我们想在捕获代码里面关闭  
  214.             //connection连接对象，因为异常发生datareader将不会存在，所以commandBehaviour.CloseConnection  
  215.             //将不会执行。  
  216.             try  
  217.             {  
  218.                 PrepareCommand(cmd, conn, null, cmdType, cmdText, null);  
  219.                 IDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);  
  220.                 cmd.Parameters.Clear();  
  221.                 return rdr;  
  222.             }  
  223.             catch  
  224.             {  
  225.                 conn.Close();  
  226.                 throw;  
  227.             }  
  228.         }  
  229.   
  230.         /// <summary>  
  231.         /// 查询数据填充到数据集DataSet中  
  232.         /// </summary>  
  233.         /// <param name="connectionString">数据库连接字符串</param>  
  234.         /// <param name="cmdType">执行命令的类型（存储过程或T-SQL，等等）</param>  
  235.         /// <param name="cmdText">命令文本</param>  
  236.         /// <param name="commandParameters">参数数组</param>  
  237.         /// <returns>数据集DataSet对象</returns>  
  238.         public static DataSet dataSet(string connectionString, CommandType cmdType, string cmdText, params IDbDataParameter[] commandParameters)  
  239.         {  
  240.             DataSet ds = new DataSet();  
  241.             IDbCommand cmd = DbFactory.CreateDbCommand();  
  242.             IDbConnection conn = DbFactory.CreateDbConnection(connectionString);  
  243.             try  
  244.             {  
  245.                 PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);  
  246.                 IDbDataAdapter sda = DbFactory.CreateDataAdapter(cmd);  
  247.                 sda.Fill(ds);  
  248.                 return ds;  
  249.             }  
  250.             catch  
  251.             {  
  252.                 conn.Close();  
  253.                 throw;  
  254.             }  
  255.             finally  
  256.             {  
  257.                 conn.Close();  
  258.                 cmd.Dispose();  
  259.             }  
  260.         }  
  261.   
  262.         /// <summary>  
  263.         /// 查询数据填充到数据集DataSet中  
  264.         /// </summary>  
  265.         /// <param name="connectionString">数据库连接字符串</param>  
  266.         /// <param name="cmdType">执行命令的类型（存储过程或T-SQL，等等）</param>  
  267.         /// <param name="cmdText">命令文本</param>  
  268.         /// <returns>数据集DataSet对象</returns>  
  269.         public static DataSet dataSet(string connectionString, CommandType cmdType, string cmdText)  
  270.         {  
  271.             DataSet ds = new DataSet();  
  272.             IDbCommand cmd = DbFactory.CreateDbCommand();  
  273.             IDbConnection conn = DbFactory.CreateDbConnection(connectionString);  
  274.             try  
  275.             {  
  276.                 PrepareCommand(cmd, conn, null, cmdType, cmdText, null);  
  277.                 IDbDataAdapter sda = DbFactory.CreateDataAdapter(cmd);  
  278.                 sda.Fill(ds);  
  279.                 return ds;  
  280.             }  
  281.             catch  
  282.             {  
  283.                 conn.Close();  
  284.                 throw;  
  285.             }  
  286.             finally  
  287.             {  
  288.                 conn.Close();  
  289.                 cmd.Dispose();  
  290.             }  
  291.         }  
  292.   
  293.         /// <summary>  
  294.         /// 依靠数据库连接字符串connectionString,  
  295.         /// 使用所提供参数，执行返回首行首列命令  
  296.         /// </summary>  
  297.         /// <remarks>  
  298.         /// e.g.:    
  299.         ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));  
  300.         /// </remarks>  
  301.         /// <param name="connectionString">数据库连接字符串</param>  
  302.         /// <param name="commandType">执行命令的类型（存储过程或T-SQL，等等）</param>  
  303.         /// <param name="commandText">存储过程名称或者T-SQL命令行</param>  
  304.         /// <param name="commandParameters">执行命令所需的参数数组</param>  
  305.         /// <returns>返回一个对象，使用Convert.To{Type}将该对象转换成想要的数据类型。</returns>  
  306.         public static object ExecuteScalar(string connectionString, CommandType cmdType, string cmdText, params IDbDataParameter[] commandParameters)  
  307.         {  
  308.             IDbCommand cmd = DbFactory.CreateDbCommand();  
  309.   
  310.             using (IDbConnection connection = DbFactory.CreateDbConnection(connectionString))  
  311.             {  
  312.                 PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);  
  313.                 object val = cmd.ExecuteScalar();  
  314.                 cmd.Parameters.Clear();  
  315.                 return val;  
  316.             }  
  317.         }  
  318.         /// <summary>  
  319.         /// 依靠数据库连接字符串connectionString,  
  320.         /// 使用所提供参数，执行返回首行首列命令  
  321.         /// </summary>  
  322.         /// <remarks>  
  323.         /// e.g.:    
  324.         ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));  
  325.         /// </remarks>  
  326.         /// <param name="connectionString">数据库连接字符串</param>  
  327.         /// <param name="commandType">执行命令的类型（存储过程或T-SQL，等等）</param>  
  328.         /// <param name="commandText">存储过程名称或者T-SQL命令行</param>  
  329.         /// <returns>返回一个对象，使用Convert.To{Type}将该对象转换成想要的数据类型。</returns>  
  330.         public static object ExecuteScalar(string connectionString, CommandType cmdType, string cmdText)  
  331.         {  
  332.             IDbCommand cmd = DbFactory.CreateDbCommand();  
  333.   
  334.             using (IDbConnection connection = DbFactory.CreateDbConnection(connectionString))  
  335.             {  
  336.                 PrepareCommand(cmd, connection, null, cmdType, cmdText, null);  
  337.                 object val = cmd.ExecuteScalar();  
  338.                 cmd.Parameters.Clear();  
  339.                 return val;  
  340.             }  
  341.         }  
  342.         /// <summary>  
  343.         ///依靠数据库连接字符串connectionString,  
  344.         /// 使用所提供参数，执行返回首行首列命令  
  345.         /// </summary>  
  346.         /// <remarks>  
  347.         /// e.g.:    
  348.         ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));  
  349.         /// </remarks>  
  350.         /// <param name="conn">数据库连接对象</param>  
  351.         /// <param name="commandType">执行命令的类型（存储过程或T-SQL，等等）</param>  
  352.         /// <param name="commandText">存储过程名称或者T-SQL命令行</param>  
  353.         /// <param name="commandParameters">执行命令所需的参数数组</param>  
  354.         /// <returns>返回一个对象，使用Convert.To{Type}将该对象转换成想要的数据类型。</returns>  
  355.         public static object ExecuteScalar(IDbConnection connection, CommandType cmdType, string cmdText, params IDbDataParameter[] commandParameters)  
  356.         {  
  357.             IDbCommand cmd = DbFactory.CreateDbCommand();  
  358.   
  359.             PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);  
  360.             object val = cmd.ExecuteScalar();  
  361.             cmd.Parameters.Clear();  
  362.             return val;  
  363.         }  
  364.         /// <summary>  
  365.         ///依靠数据库连接字符串connectionString,  
  366.         /// 使用所提供参数，执行返回首行首列命令  
  367.         /// </summary>  
  368.         /// <remarks>  
  369.         /// e.g.:    
  370.         ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));  
  371.         /// </remarks>  
  372.         /// <param name="conn">数据库连接对象</param>  
  373.         /// <param name="commandType">执行命令的类型（存储过程或T-SQL，等等）</param>  
  374.         /// <param name="commandText">存储过程名称或者T-SQL命令行</param>  
  375.         /// <param name="commandParameters">执行命令所需的参数数组</param>  
  376.         /// <returns>返回一个对象，使用Convert.To{Type}将该对象转换成想要的数据类型。</returns>  
  377.         public static object ExecuteScalar(IDbConnection connection, CommandType cmdType, string cmdText)  
  378.         {  
  379.             IDbCommand cmd = DbFactory.CreateDbCommand();  
  380.   
  381.             PrepareCommand(cmd, connection, null, cmdType, cmdText, null);  
  382.             object val = cmd.ExecuteScalar();  
  383.             cmd.Parameters.Clear();  
  384.             return val;  
  385.         }  
  386.   
  387.   
  388.         /// <summary>  
  389.         /// add parameter array to the cache  
  390.         /// </summary>  
  391.         /// <param name="cacheKey">Key to the parameter cache</param>  
  392.         /// <param name="cmdParms">an array of SqlParamters to be cached</param>  
  393.         public static void CacheParameters(string cacheKey, params IDbDataParameter[] commandParameters)  
  394.         {  
  395.             parmCache[cacheKey] = commandParameters;  
  396.         }  
  397.   
  398.         /// <summary>  
  399.         /// 查询缓存参数  
  400.         /// </summary>  
  401.         /// <param name="cacheKey">使用缓存名称查找值</param>  
  402.         /// <returns>缓存参数数组</returns>  
  403.         public static IDbDataParameter[] GetCachedParameters(string cacheKey)  
  404.         {  
  405.             IDbDataParameter[] cachedParms = (IDbDataParameter[])parmCache[cacheKey];  
  406.   
  407.             if (cachedParms == null)  
  408.                 return null;  
  409.   
  410.             IDbDataParameter[] clonedParms = new IDbDataParameter[cachedParms.Length];  
  411.   
  412.             for (int i = 0, j = cachedParms.Length; i < j; i++)  
  413.                 clonedParms[i] = (IDbDataParameter)((ICloneable)cachedParms[i]).Clone();  
  414.   
  415.             return clonedParms;  
  416.         }  
  417.   
  418.         /// <summary>  
  419.         /// 为即将执行准备一个命令  
  420.         /// </summary>  
  421.         /// <param name="cmd">SqlCommand对象</param>  
  422.         /// <param name="conn">SqlConnection对象</param>  
  423.         /// <param name="trans">IDbTransaction对象</param>  
  424.         /// <param name="cmdType">执行命令的类型（存储过程或T-SQL，等等）</param>  
  425.         /// <param name="cmdText">存储过程名称或者T-SQL命令行, e.g. Select * from Products</param>  
  426.         /// <param name="cmdParms">SqlParameters to use in the command</param>  
  427.         private static void PrepareCommand(IDbCommand cmd, IDbConnection conn, IDbTransaction trans, CommandType cmdType, string cmdText, IDbDataParameter[] cmdParms)  
  428.         {  
  429.             if (conn.State != ConnectionState.Open)  
  430.                 conn.Open();  
  431.   
  432.             cmd.Connection = conn;  
  433.             cmd.CommandText = cmdText;  
  434.   
  435.             if (trans != null)  
  436.                 cmd.Transaction = trans;  
  437.   
  438.             cmd.CommandType = cmdType;  
  439.   
  440.             if (cmdParms != null)  
  441.             {  
  442.                 foreach (IDbDataParameter parm in cmdParms)  
  443.                     cmd.Parameters.Add(parm);  
  444.             }  
  445.         }  
  446.   
  447.         /// <summary>  
  448.         /// 根据传入的Key获取配置文件中  
  449.         /// 相应Key的数据库连接字符串  
  450.         /// </summary>  
  451.         /// <param name="Key"></param>  
  452.         /// <returns></returns>  
  453.         public static string GetConnectionString(string Key)  
  454.         {  
  455.             try  
  456.             {  
  457.                 return CommonUtils.GetConfigValueByKey(Key);  
  458.             }  
  459.             catch  
  460.             {  
  461.                 throw new Exception("web.config文件appSettings中数据库连接字符串未配置或配置错误，必须为Key=\"connectionString\"");  
  462.             }  
  463.         }        
  464.   
  465.         /// <summary>  
  466.         /// 用于数据库类型的字符串枚举转换  
  467.         /// </summary>  
  468.         /// <typeparam name="T"></typeparam>  
  469.         /// <param name="value"></param>  
  470.         /// <returns></returns>  
  471.         public static T DatabaseTypeEnumParse<T>(string value)  
  472.         {  
  473.             try  
  474.             {  
  475.                 return CommonUtils.EnumParse<T>(value);  
  476.             }  
  477.             catch  
  478.             {  
  479.                 throw new Exception("数据库类型\"" + value + "\"错误，请检查！");  
  480.             }  
  481.         }                               
  482.     }  
  483. }  

在上面代码中用到了DbFactory类来创建数据库连接，适配器，事务等等对象。这里的工厂类的作用是根据配置文件的DbType指定的数据库类型来创建，目前支持3种数据库类型，如果需要新增数据库类型，只需修改此类中代码，其它地方无需改变。

[csharp] view plaincopy
  1. using System;  
  2. using System.Configuration;  
  3. using System.Data;  
  4. using System.Collections;  
  5. using System.Data.SqlClient;  
  6. using System.Data.OracleClient;  
  7. using System.Data.OleDb;  
  8. using System.Data.Odbc;  
  9. using System.Orm.Common;  
  10.   
  11. namespace System.Orm.DBUtility  
  12. {      
  13.     public class DbFactory  
  14.     {                  
  15.           
  16.   
  17.         /// <summary>  
  18.         /// 根据配置文件中所配置的数据库类型  
  19.         /// 来获取命令参数中的参数符号oracle为":",sqlserver为"@"  
  20.         /// </summary>  
  21.         /// <returns></returns>  
  22.         public static string CreateDbParmCharacter()  
  23.         {  
  24.             string character = string.Empty;  
  25.   
  26.             switch (AdoHelper.DbType)  
  27.             {  
  28.                 case DatabaseType.SQLSERVER:  
  29.                     character = "@";  
  30.                     break;  
  31.                 case DatabaseType.ORACLE:  
  32.                     character = ":";  
  33.                     break;  
  34.                 case DatabaseType.ACCESS:  
  35.                     character = "@";  
  36.                     break;  
  37.                 default:  
  38.                     throw new Exception("数据库类型目前不支持！");  
  39.             }  
  40.   
  41.             return character;  
  42.         }  
  43.   
  44.         /// <summary>  
  45.         /// 根据配置文件中所配置的数据库类型和传入的  
  46.         /// 数据库链接字符串来创建相应数据库连接对象  
  47.         /// </summary>  
  48.         /// <param name="connectionString"></param>  
  49.         /// <returns></returns>  
  50.         public static IDbConnection CreateDbConnection(string connectionString)  
  51.         {  
  52.             IDbConnection conn = null;  
  53.             switch (AdoHelper.DbType)  
  54.             {  
  55.                 case DatabaseType.SQLSERVER:  
  56.                     conn = new SqlConnection(connectionString);  
  57.                     break;  
  58.                 case DatabaseType.ORACLE:  
  59.                     conn = new OracleConnection(connectionString);  
  60.                     break;  
  61.                 case DatabaseType.ACCESS:  
  62.                     conn = new OleDbConnection(connectionString);  
  63.                     break;  
  64.                 default:   
  65.                     throw new Exception("数据库类型目前不支持！");  
  66.             }  
  67.   
  68.             return conn;  
  69.         }  
  70.   
  71.         /// <summary>  
  72.         /// 根据配置文件中所配置的数据库类型  
  73.         /// 来创建相应数据库命令对象  
  74.         /// </summary>  
  75.         /// <returns></returns>  
  76.         public static IDbCommand CreateDbCommand()  
  77.         {  
  78.             IDbCommand cmd = null;  
  79.             switch (AdoHelper.DbType)  
  80.             {  
  81.                 case DatabaseType.SQLSERVER:  
  82.                     cmd = new SqlCommand();  
  83.                     break;  
  84.                 case DatabaseType.ORACLE:  
  85.                     cmd = new OracleCommand();  
  86.                     break;  
  87.                 case DatabaseType.ACCESS:  
  88.                     cmd = new OleDbCommand();  
  89.                     break;  
  90.                 default:   
  91.                     throw new Exception("数据库类型目前不支持！");  
  92.             }  
  93.   
  94.             return cmd;  
  95.         }  
  96.   
  97.         /// <summary>  
  98.         /// 根据配置文件中所配置的数据库类型  
  99.         /// 来创建相应数据库适配器对象  
  100.         /// </summary>  
  101.         /// <returns></returns>  
  102.         public static IDbDataAdapter CreateDataAdapter()  
  103.         {  
  104.             IDbDataAdapter adapter = null;  
  105.             switch (AdoHelper.DbType)  
  106.             {  
  107.                 case DatabaseType.SQLSERVER:  
  108.                     adapter = new SqlDataAdapter();  
  109.                     break;  
  110.                 case DatabaseType.ORACLE:  
  111.                     adapter = new OracleDataAdapter();  
  112.                     break;  
  113.                 case DatabaseType.ACCESS:  
  114.                     adapter = new OleDbDataAdapter();  
  115.                     break;  
  116.                 default:   
  117.                     throw new Exception("数据库类型目前不支持！");  
  118.             }  
  119.   
  120.             return adapter;  
  121.         }  
  122.   
  123.         /// <summary>  
  124.         /// 根据配置文件中所配置的数据库类型  
  125.         /// 和传入的命令对象来创建相应数据库适配器对象  
  126.         /// </summary>  
  127.         /// <returns></returns>  
  128.         public static IDbDataAdapter CreateDataAdapter(IDbCommand cmd)  
  129.         {  
  130.             IDbDataAdapter adapter = null;  
  131.             switch (AdoHelper.DbType)  
  132.             {  
  133.                 case DatabaseType.SQLSERVER:  
  134.                     adapter = new SqlDataAdapter((SqlCommand)cmd);  
  135.                     break;  
  136.                 case DatabaseType.ORACLE:  
  137.                     adapter = new OracleDataAdapter((OracleCommand)cmd);  
  138.                     break;  
  139.                 case DatabaseType.ACCESS:  
  140.                     adapter = new OleDbDataAdapter((OleDbCommand)cmd);  
  141.                     break;  
  142.                 default: throw new Exception("数据库类型目前不支持！");  
  143.             }  
  144.   
  145.             return adapter;  
  146.         }  
  147.   
  148.         /// <summary>  
  149.         /// 根据配置文件中所配置的数据库类型  
  150.         /// 来创建相应数据库的参数对象  
  151.         /// </summary>  
  152.         /// <returns></returns>  
  153.         public static IDbDataParameter CreateDbParameter()  
  154.         {  
  155.             IDbDataParameter param = null;  
  156.             switch (AdoHelper.DbType)  
  157.             {  
  158.                 case DatabaseType.SQLSERVER:  
  159.                     param = new SqlParameter();  
  160.                     break;  
  161.                 case DatabaseType.ORACLE:  
  162.                     param = new OracleParameter();  
  163.                     break;  
  164.                 case DatabaseType.ACCESS:  
  165.                     param = new OleDbParameter();  
  166.                     break;  
  167.                 default:  
  168.                     throw new Exception("数据库类型目前不支持！");  
  169.             }  
  170.   
  171.             return param;  
  172.         }  
  173.   
  174.         /// <summary>  
  175.         /// 根据配置文件中所配置的数据库类型  
  176.         /// 和传入的参数来创建相应数据库的参数数组对象  
  177.         /// </summary>  
  178.         /// <returns></returns>  
  179.         public static IDbDataParameter[] CreateDbParameters(int size)  
  180.         {  
  181.             int i = 0;  
  182.             IDbDataParameter[] param = null;  
  183.             switch (AdoHelper.DbType)  
  184.             {  
  185.                 case DatabaseType.SQLSERVER:  
  186.                     param = new SqlParameter[size];  
  187.                     while (i < size) { param[i] = new SqlParameter(); i++; }  
  188.                     break;  
  189.                 case DatabaseType.ORACLE:  
  190.                     param = new OracleParameter[size];  
  191.                     while (i < size) { param[i] = new OracleParameter(); i++; }  
  192.                     break;  
  193.                 case DatabaseType.ACCESS:  
  194.                     param = new OleDbParameter[size];  
  195.                     while (i < size){param[i] = new OleDbParameter();i++;}  
  196.                     break;  
  197.                 default:   
  198.                     throw new Exception("数据库类型目前不支持！");  
  199.   
  200.             }  
  201.   
  202.             return param;  
  203.         }  
  204.   
  205.         /// <summary>  
  206.         /// 根据配置文件中所配置的数据库类型  
  207.         /// 来创建相应数据库的事物对象  
  208.         /// </summary>  
  209.         /// <returns></returns>  
  210.         public static IDbTransaction CreateDbTransaction()  
  211.         {  
  212.             IDbConnection conn = CreateDbConnection(AdoHelper.ConnectionString);  
  213.   
  214.             if (conn.State == ConnectionState.Closed)  
  215.             {  
  216.                 conn.Open();  
  217.             }  
  218.   
  219.             return conn.BeginTransaction();             
  220.         }                    
  221.     }  
  222. }  

在AdoHelper类中用到了CommonUtils工具类，DbFactory类中用到了DatabaseType枚举

[csharp] view plaincopy
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using System.Configuration;  
  5. using System.Reflection;  
  6.   
  7. namespace System.Orm.Common  
  8. {  
  9.     public class CommonUtils  
  10.     {  
  11.         /// <summary>  
  12.         /// 用于字符串和枚举类型的转换  
  13.         /// </summary>  
  14.         /// <typeparam name="T"></typeparam>  
  15.         /// <param name="value"></param>  
  16.         /// <returns></returns>  
  17.         public static T EnumParse<T>(string value)  
  18.         {  
  19.             try  
  20.             {  
  21.                 return (T)Enum.Parse(typeof(T), value);  
  22.             }  
  23.             catch  
  24.             {  
  25.                 throw new Exception("传入的值与枚举值不匹配。");  
  26.             }  
  27.         }  
  28.   
  29.         /// <summary>  
  30.         /// 根据传入的Key获取配置文件中的Value值  
  31.         /// </summary>  
  32.         /// <param name="Key"></param>  
  33.         /// <returns></returns>  
  34.         public static string GetConfigValueByKey(string Key)  
  35.         {  
  36.             try  
  37.             {  
  38.                 return ConfigurationManager.AppSettings[Key].ToString();  
  39.             }  
  40.             catch  
  41.             {  
  42.                 throw new Exception("web.config中 Key=\"" + Key + "\"未配置或配置错误！");  
  43.             }  
  44.         }  
  45.   
  46.         public static Boolean IsNullOrEmpty(Object value)  
  47.         {  
  48.             if (value == null)  
  49.                 return true;  
  50.             if (String.IsNullOrEmpty(value.ToString()))  
  51.                 return true;  
  52.             return false;  
  53.         }  
  54.     }  
  55. }  
  56.   
  57. using System;  
  58. using System.Collections.Generic;  
  59. using System.Text;  
  60.   
  61. namespace System.Orm.DBUtility  
  62. {  
  63.     /// <summary>  
  64.     /// 数据库类型枚举，需要扩展类型可在此添加  
  65.     /// </summary>  
  66.     public enum DatabaseType  
  67.     {  
  68.         SQLSERVER,  
  69.         ORACLE,  
  70.         ACCESS,  
  71.         MYSQL  
  72.     }  
  73. }  

在CommonUtils类中使用到了TypeUtils类进行类型转换：

[csharp] view plaincopy
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4.   
  5. namespace System.Orm.Common  
  6. {  
  7.     public class TypeUtils  
  8.     {  
  9.         public static object ConvertForType(object value,Type type)  
  10.         {  
  11.             switch (type.FullName)  
  12.             {  
  13.                 case "System.String":  
  14.                     value = value.ToString();  
  15.                     break;  
  16.                 case "System.Boolean":  
  17.                     value = bool.Parse(value.ToString());  
  18.                     break;  
  19.                 case "System.Int16":  
  20.                 case "System.Int32":  
  21.                 case "System.Int64":  
  22.                     value = int.Parse(value.ToString());  
  23.                     break;  
  24.                 case "System.Double":  
  25.                     value = double.Parse(value.ToString());  
  26.                     break;  
  27.                 case "System.Decimal":  
  28.                     value = new decimal(double.Parse(value.ToString()));  
  29.                     break;                                                               
  30.             }  
  31.   
  32.             return value;  
  33.         }  
  34.     }  
  35. }  

数据库操作类代码基本如上全部。
　AdoHelper支持多数据库操作的封装(2)
目标效果预览　

柏港为您推荐了一些相关资讯

c# 封装Dapper操作类 C#高效数据库操作库Dapper .net core 各版本支持的操作系统（服务器） EFCore所支持的数据库 .net core ef core 支持的数据库及nuget程序包 VisualStudio_android-23_x86_phone 模拟器支持电脑键盘操作 C#对SQLite数据库的操作 sql service出现文件激活错误。物理文件名 'E:/正式数据库备份/2018/***2018.mdf' 可能不正确。请诊断并更正其他错误，然后重试此操作 .NET 百万级 大数据插入、更新 ，支持多种数据库 C#如何使用SqlSugar操作MySQL数据库

© Copyright 2014 - 2025 柏港建站平台 ejk5.com. 渝ICP备16000791号-4