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

代码如下：

AdoHelper类代码

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
    {
        //取web.config中配置的数据库类型，配置方法如下：
        #region "web.config数据库类型和连接配置"
        /*


        */
        #endregion
        private static string strDbType = CommonUtils.GetConfigValueByKey("DbType").ToUpper();

        //将数据库类型转换成枚举类型
        public static DatabaseType dbType = DbHelper.DatabaseTypeEnumParse<DatabaseType>(strDbType);

        //取web.config中配置的数据库连接，配置方法如下：
        #region "web.config数据库类型和连接配置"
        /*




        */
        #endregion
        public static string connectionString = GetConnectionString("connectionString");

        private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable());

        ///

        ///通过提供的参数，执行无结果集的数据库操作命令
        /// 并返回执行数据库操作所影响的行数。
        ///

        /// 数据库连接字符串
        /// 执行命令的类型（存储过程或T-SQL，等等）
        /// 存储过程名称或者T-SQL命令行<
        /// 执行命令所需的参数数组
        /// 返回通过执行命令所影响的行数
        public static int ExecuteNonQuery(string connectionString, CommandType cmdType, string cmdText, params IDbDataParameter[] commandParameters)
        {

            IDbCommand cmd = CreateDbCommand();

            using (IDbConnection conn = CreateDbConnection(connectionString))
            {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                int val = cmd.ExecuteNonQuery();
                cmd.Parameters.Clear();
                return val;
            }
        }
        ///

        ///通过提供的参数，执行无结果集的数据库操作命令
        /// 并返回执行数据库操作所影响的行数。
        ///

        /// 数据库连接字符串
        /// 执行命令的类型（存储过程或T-SQL，等等）
        /// 存储过程名称或者T-SQL命令行<
        /// 返回通过执行命令所影响的行数
        public static int ExecuteNonQuery(string connectionString, CommandType cmdType, string cmdText)
        {
            IDbCommand cmd = CreateDbCommand();

            using (IDbConnection conn = CreateDbConnection(connectionString))
            {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, null);
                int val = cmd.ExecuteNonQuery();
                cmd.Parameters.Clear();
                return val;
            }
        }

        ///

        ///通过提供的参数，执行无结果集返回的数据库操作命令
        ///并返回执行数据库操作所影响的行数。
        ///

        ///
        /// e.g.:
        ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        ///
        /// 数据库连接对象
        /// 执行命令的类型（存储过程或T-SQL，等等）
        /// 存储过程名称或者T-SQL命令行
        /// 执行命令所需的参数数组
        /// 返回通过执行命令所影响的行数
        public static int ExecuteNonQuery(IDbConnection connection, CommandType cmdType, string cmdText, params IDbDataParameter[] commandParameters)
        {
            IDbCommand cmd = CreateDbCommand();

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

        ///通过提供的参数，执行无结果集返回的数据库操作命令
        ///并返回执行数据库操作所影响的行数。
        ///

        ///
        /// e.g.:
        ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        ///
        /// 数据库连接对象
        /// 执行命令的类型（存储过程或T-SQL，等等）
        /// 存储过程名称或者T-SQL命令行
        /// 返回通过执行命令所影响的行数
        public static int ExecuteNonQuery(IDbConnection connection, CommandType cmdType, string cmdText)
        {
            IDbCommand cmd = CreateDbCommand();

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

        ///

        ///通过提供的参数，执行无结果集返回的数据库操作命令
        ///并返回执行数据库操作所影响的行数。
        ///

        ///
        /// e.g.:
        ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        ///
        /// sql事务对象
        /// 执行命令的类型（存储过程或T-SQL，等等）
        /// 存储过程名称或者T-SQL命令行<
        /// 执行命令所需的参数数组
        /// 返回通过执行命令所影响的行数
        public static int ExecuteNonQuery(IDbTransaction trans, CommandType cmdType, string cmdText, params IDbDataParameter[] commandParameters)
        {
            IDbConnection conn = null;
            if (trans == null)
            {
                conn = CreateDbConnection(connectionString);
            }
            else
            {
                conn = trans.Connection;
            }

            IDbCommand cmd = CreateDbCommand();
            PrepareCommand(cmd, conn, trans, cmdType, cmdText, commandParameters);
            int val = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            return val;
        }
        ///

        ///通过提供的参数，执行无结果集返回的数据库操作命令
        ///并返回执行数据库操作所影响的行数。
        ///

        ///
        /// e.g.:
        ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        ///
        /// sql事务对象
        /// 执行命令的类型（存储过程或T-SQL，等等）
        /// 存储过程名称或者T-SQL命令行<
        /// 返回通过执行命令所影响的行数
        public static int ExecuteNonQuery(IDbTransaction trans, CommandType cmdType, string cmdText)
        {
            IDbCommand cmd = CreateDbCommand();
            PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, null);
            int val = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            return val;
        }
        ///

        /// 使用提供的参数，执行有结果集返回的数据库操作命令
        /// 并返回SqlDataReader对象
        ///

        ///
        /// e.g.:
        ///  SqlDataReader r = ExecuteReader(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        ///
        /// 数据库连接字符串
        /// 执行命令的类型（存储过程或T-SQL，等等）
        /// 存储过程名称或者T-SQL命令行<
        /// 执行命令所需的参数数组
        /// 返回SqlDataReader对象
        public static IDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText, params IDbDataParameter[] commandParameters)
        {
            IDbCommand cmd = CreateDbCommand();
            IDbConnection conn = CreateDbConnection(connectionString);

            //我们在这里使用一个 try/catch,因为如果PrepareCommand方法抛出一个异常，我们想在捕获代码里面关闭
            //connection连接对象，因为异常发生datareader将不会存在，所以commandBehaviour.CloseConnection
            //将不会执行。
            try
            {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                IDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                cmd.Parameters.Clear();
                return rdr;
            }
            catch
            {
                conn.Close();
                throw;
            }
        }
        ///

        ///使用提供的参数，执行有结果集返回的数据库操作命令
        /// 并返回SqlDataReader对象
        ///

        /// 数据库连接字符串
        /// 执行命令的类型（存储过程或T-SQL，等等）
        /// 存储过程名称或者T-SQL命令行<
        /// 返回SqlDataReader对象
        public static IDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText)
        {
            IDbCommand cmd = CreateDbCommand();
            IDbConnection conn = CreateDbConnection(connectionString);

            //我们在这里使用一个 try/catch,因为如果PrepareCommand方法抛出一个异常，我们想在捕获代码里面关闭
            //connection连接对象，因为异常发生datareader将不会存在，所以commandBehaviour.CloseConnection
            //将不会执行。
            try
            {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, null);
                IDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                cmd.Parameters.Clear();
                return rdr;
            }
            catch
            {
                conn.Close();
                throw;
            }
        }

        ///

/// 查询数据填充到数据集DataSet中
///

        /// 数据库连接字符串
        /// 执行命令的类型（存储过程或T-SQL，等等）
        /// 命令文本
        /// 参数数组
        /// 数据集DataSet对象
        public static DataSet dataSet(string connectionString, CommandType cmdType, string cmdText, params IDbDataParameter[] commandParameters)
        {
            DataSet ds = new DataSet();
            IDbCommand cmd = CreateDbCommand();
            IDbConnection conn = CreateDbConnection(connectionString);
            try
            {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                IDbDataAdapter sda = CreateDataAdapter(cmd);
                sda.Fill(ds);
                return ds;
            }
            catch
            {
                conn.Close();
                throw;
            }
            finally
            {
                conn.Close();
                cmd.Dispose();
            }
        }

        ///

/// 查询数据填充到数据集DataSet中
///

        /// 数据库连接字符串
        /// 执行命令的类型（存储过程或T-SQL，等等）
        /// 命令文本
        /// 数据集DataSet对象
        public static DataSet dataSet(string connectionString, CommandType cmdType, string cmdText)
        {
            DataSet ds = new DataSet();
            IDbCommand cmd = CreateDbCommand();
            IDbConnection conn = CreateDbConnection(connectionString);
            try
            {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, null);
                IDbDataAdapter sda = CreateDataAdapter(cmd);
                sda.Fill(ds);
                return ds;
            }
            catch
            {
                conn.Close();
                throw;
            }
            finally
            {
                conn.Close();
                cmd.Dispose();
            }
        }

        ///

        /// 依靠数据库连接字符串connectionString,
        /// 使用所提供参数，执行返回首行首列命令
        ///

        ///
        /// e.g.:
        ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        ///
        /// 数据库连接字符串
        /// 执行命令的类型（存储过程或T-SQL，等等）
        /// 存储过程名称或者T-SQL命令行
        /// 执行命令所需的参数数组
        /// 返回一个对象，使用Convert.To{Type}将该对象转换成想要的数据类型。
        public static object ExecuteScalar(string connectionString, CommandType cmdType, string cmdText, params IDbDataParameter[] commandParameters)
        {
            IDbCommand cmd = CreateDbCommand();

            using (IDbConnection connection = CreateDbConnection(connectionString))
            {
                PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
                object val = cmd.ExecuteScalar();
                cmd.Parameters.Clear();
                return val;
            }
        }
        ///

        /// 依靠数据库连接字符串connectionString,
        /// 使用所提供参数，执行返回首行首列命令
        ///

        ///
        /// e.g.:
        ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        ///
        /// 数据库连接字符串
        /// 执行命令的类型（存储过程或T-SQL，等等）
        /// 存储过程名称或者T-SQL命令行
        /// 返回一个对象，使用Convert.To{Type}将该对象转换成想要的数据类型。
        public static object ExecuteScalar(string connectionString, CommandType cmdType, string cmdText)
        {
            IDbCommand cmd = CreateDbCommand();

            using (IDbConnection connection = CreateDbConnection(connectionString))
            {
                PrepareCommand(cmd, connection, null, cmdType, cmdText, null);
                object val = cmd.ExecuteScalar();
                cmd.Parameters.Clear();
                return val;
            }
        }
        ///

        ///依靠数据库连接字符串connectionString,
        /// 使用所提供参数，执行返回首行首列命令
        ///

        ///
        /// e.g.:
        ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        ///
        /// 数据库连接对象
        /// 执行命令的类型（存储过程或T-SQL，等等）
        /// 存储过程名称或者T-SQL命令行
        /// 执行命令所需的参数数组
        /// 返回一个对象，使用Convert.To{Type}将该对象转换成想要的数据类型。
        public static object ExecuteScalar(IDbConnection connection, CommandType cmdType, string cmdText, params IDbDataParameter[] commandParameters)
        {
            IDbCommand cmd = CreateDbCommand();

            PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
            object val = cmd.ExecuteScalar();
            cmd.Parameters.Clear();
            return val;
        }
        ///

        ///依靠数据库连接字符串connectionString,
        /// 使用所提供参数，执行返回首行首列命令
        ///

        ///
        /// e.g.:
        ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        ///
        /// 数据库连接对象
        /// 执行命令的类型（存储过程或T-SQL，等等）
        /// 存储过程名称或者T-SQL命令行
        /// 执行命令所需的参数数组
        /// 返回一个对象，使用Convert.To{Type}将该对象转换成想要的数据类型。
        public static object ExecuteScalar(IDbConnection connection, CommandType cmdType, string cmdText)
        {
            IDbCommand cmd = CreateDbCommand();

            PrepareCommand(cmd, connection, null, cmdType, cmdText, null);
            object val = cmd.ExecuteScalar();
            cmd.Parameters.Clear();
            return val;
        }

        ///

/// add parameter array to the cache
///

        /// Key to the parameter cache
        /// an array of SqlParamters to be cached
        public static void CacheParameters(string cacheKey, params IDbDataParameter[] commandParameters)
        {
            parmCache[cacheKey] = commandParameters;
        }

        ///

/// 查询缓存参数
///

        /// 使用缓存名称查找值
        /// 缓存参数数组
        public static IDbDataParameter[] GetCachedParameters(string cacheKey)
        {
            IDbDataParameter[] cachedParms = (IDbDataParameter[])parmCache[cacheKey];

            if (cachedParms == null)
                return null;

            IDbDataParameter[] clonedParms = new IDbDataParameter[cachedParms.Length];

            for (int i = 0, j = cachedParms.Length; i < j; i++)
                clonedParms[i] = (IDbDataParameter)((ICloneable)cachedParms[i]).Clone();

            return clonedParms;
        }

        ///

/// 为即将执行准备一个命令
///

        /// SqlCommand对象
        /// SqlConnection对象
        /// IDbTransaction对象
        /// 执行命令的类型（存储过程或T-SQL，等等）
        /// 存储过程名称或者T-SQL命令行, e.g. Select * from Products
        /// SqlParameters to use in the command
        private static void PrepareCommand(IDbCommand cmd, IDbConnection conn, IDbTransaction trans, CommandType cmdType, string cmdText, IDbDataParameter[] cmdParms)
        {
            if (conn.State != ConnectionState.Open)
                conn.Open();

            cmd.Connection = conn;
            cmd.CommandText = cmdText;

            if (trans != null)
                cmd.Transaction = trans;

            cmd.CommandType = cmdType;

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

        ///

        /// 根据传入的Key获取配置文件中
        /// 相应Key的数据库连接字符串
        ///

        ///
        ///
        public static string GetConnectionString(string Key)
        {
            try
            {
                return CommonUtils.GetConfigValueByKey(Key);
            }
            catch
            {
                throw new Exception("web.config文件appSettings中数据库连接字符串未配置或配置错误，必须为Key=\"connectionString\"");
            }
        }

        /*
         根据配置文件中所配置的数据库类型
         来获取命令参数中的参数符号oracle为":",sqlserver为"@"
        */
        public static string GetDbParameterCharacter()
        {
            return DbHelper.GetDbParameterCharacter();
        }

        /*
         根据配置文件中所配置的数据库类型和传入的
         数据库链接字符串来创建相应数据库连接对象
        */
        public static IDbConnection CreateDbConnection(string connectionString)
        {
            return DbHelper.CreateDbConnection(connectionString);
        }

        /*
         根据配置文件中所配置的数据库类型
         来创建相应数据库命令对象
        */
        public static IDbCommand CreateDbCommand()
        {
            return DbHelper.CreateDbCommand();
        }

        /*
         根据配置文件中所配置的数据库类型
         来创建相应数据库适配器对象
        */
        public static IDbDataAdapter CreateDataAdapter()
        {
            return DbHelper.CreateDataAdapter();
        }

        /*
         根据配置文件中所配置的数据库类型
         和传入的命令对象来创建相应数据库适配器对象
        */
        public static IDbDataAdapter CreateDataAdapter(IDbCommand cmd)
        {
            return DbHelper.CreateDataAdapter(cmd);
        }

        /*
         根据配置文件中所配置的数据库类型
         来创建相应数据库的参数对象
        */
        public static IDbDataParameter CreateDbParameter()
        {
            return DbHelper.CreateDbParameter();
        }

        /*
         根据配置文件中所配置的数据库类型
         和传入的参数来创建相应数据库的参数数组对象
        */
        public static IDbDataParameter[] CreateDbParameters(int size)
        {
            return DbHelper.CreateDbParameters(size);
        }

        /*
         根据配置文件中所配置的数据库类型
         来创建相应数据库的事物对象
        */
        public static IDbTransaction CreateDbTransaction()
        {
            return DbHelper.CreateDbTransaction();
        }
    }
}

在上面代码中用到了DbHelper类来创建数据库连接，适配器，事务等等对象。

代码如下：

DbHelper类代码

using System;
using System.Configuration;
using System.Data;
using System.Collections;
using System.Data.SqlClient;
using System.Data.OracleClient;
using System.Orm.Common;

namespace System.Orm.DBUtility
{
    public class DbHelper : AdoHelper
    {
        ///

        /// 根据配置文件中所配置的数据库类型
        /// 来获取命令参数中的参数符号oracle为":",sqlserver为"@"
        ///

        ///
        public new static string GetDbParameterCharacter()
        {
            string character = string.Empty;

            switch (dbType)
            {
                case DatabaseType.SQLSERVER:
                    character = "@";
                    break;
                case DatabaseType.ORACLE:
                    character = ":";
                    break;
            }

            return character;
        }

        ///

        /// 根据配置文件中所配置的数据库类型和传入的
        /// 数据库链接字符串来创建相应数据库连接对象
        ///

        ///
        ///
        public new static IDbConnection CreateDbConnection(string connectionString)
        {
            IDbConnection conn = null;
            switch (dbType)
            {
                case DatabaseType.SQLSERVER:
                    conn = new SqlConnection(connectionString);
                    break;
                case DatabaseType.ORACLE:
                    conn = new OracleConnection(connectionString);
                    break;
            }

            return conn;
        }

        ///

        /// 根据配置文件中所配置的数据库类型
        /// 来创建相应数据库命令对象
        ///

        ///
        public new static IDbCommand CreateDbCommand()
        {
            IDbCommand cmd = null;
            switch (dbType)
            {
                case DatabaseType.SQLSERVER:
                    cmd = new SqlCommand();
                    break;
                case DatabaseType.ORACLE:
                    cmd = new OracleCommand();
                    break;
            }

            return cmd;
        }

        ///

        /// 根据配置文件中所配置的数据库类型
        /// 来创建相应数据库适配器对象
        ///

        ///
        public new static IDbDataAdapter CreateDataAdapter()
        {
            IDbDataAdapter adapter = null;
            switch (dbType)
            {
                case DatabaseType.SQLSERVER:
                    adapter = new SqlDataAdapter();
                    break;
                case DatabaseType.ORACLE:
                    adapter = new OracleDataAdapter();
                    break;
            }

            return adapter;
        }

        ///

        /// 根据配置文件中所配置的数据库类型
        /// 和传入的命令对象来创建相应数据库适配器对象
        ///

        ///
        public new static IDbDataAdapter CreateDataAdapter(IDbCommand cmd)
        {
            IDbDataAdapter adapter = null;
            switch (dbType)
            {
                case DatabaseType.SQLSERVER:
                    adapter = new SqlDataAdapter((SqlCommand)cmd);
                    break;
                case DatabaseType.ORACLE:
                    adapter = new OracleDataAdapter((OracleCommand)cmd);
                    break;
            }

            return adapter;
        }

        ///

        /// 根据配置文件中所配置的数据库类型
        /// 来创建相应数据库的参数对象
        ///

        ///
        public new static IDbDataParameter CreateDbParameter()
        {
            IDbDataParameter param = null;
            switch (dbType)
            {
                case DatabaseType.SQLSERVER:
                    param = new SqlParameter();
                    break;
                case DatabaseType.ORACLE:
                    param = new OracleParameter();
                    break;
            }

            return param;
        }

        ///

        /// 根据配置文件中所配置的数据库类型
        /// 和传入的参数来创建相应数据库的参数数组对象
        ///

        ///
        public new static IDbDataParameter[] CreateDbParameters(int size)
        {
            int i;
            IDbDataParameter[] param = null;
            switch (dbType)
            {
                case DatabaseType.SQLSERVER:
                    i = 0;
                    param = new SqlParameter[size];
                    while (i < size) { param[i] = new SqlParameter(); i++; }
                    break;
                case DatabaseType.ORACLE:
                    i = 0;
                    param = new OracleParameter[size];
                    while (i < size) { param[i] = new OracleParameter(); i++; }
                    break;
            }

            return param;
        }

        ///

        /// 根据配置文件中所配置的数据库类型
        /// 来创建相应数据库的事物对象
        ///

        ///
        public new static IDbTransaction CreateDbTransaction()
        {
            IDbTransaction trans = null;
            switch (dbType)
            {
                case DatabaseType.SQLSERVER:
                    trans = (IDbTransaction)CreateSqlTransaction();
                    break;
                case DatabaseType.ORACLE:
                    trans = (IDbTransaction)CreateOracleTransaction();
                    break;
            }

            return trans;
        }

        ///

/// 创建SQLSERVER数据库事物对象
///

        ///
        private static SqlTransaction CreateSqlTransaction()
        {
            SqlConnection conn = CreateSqlConnection();

            if (conn.State == ConnectionState.Closed)
            {
                conn.Open();
            }

            SqlTransaction trans = conn.BeginTransaction();

            return trans;

        }
        ///

/// 创建SQLSERVER数据库连接
///

        ///
        private static SqlConnection CreateSqlConnection()
        {
            return new SqlConnection(connectionString);
        }

        ///

/// 创建ORACLE数据库事物对象
///

        ///
        private static OracleTransaction CreateOracleTransaction()
        {
            OracleConnection conn = CreateOracleConnection();

            if (conn.State == ConnectionState.Closed)
            {
                conn.Open();
            }

            return conn.BeginTransaction();
        }
        ///

/// 创建ORACLE数据库连接
///

        ///
        private static OracleConnection CreateOracleConnection()
        {
            return new OracleConnection(connectionString);
        }

        ///

/// 用于数据库类型的字符串枚举转换
///

        ///
        ///
        ///
        public static T DatabaseTypeEnumParse<T>(string value)
        {
            try
            {
                return CommonUtils.EnumParse<T>(value);
            }
            catch
            {
                throw new Exception("数据库类型\"" + value + "\"错误，请检查！");
            }
        }
    }
}

在DbHelper类中又用到了CommonUtils通用类和DatabaseType枚举

代码如下：

CommonUtils和DatabaseType代码

using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;
using System.Reflection;

namespace System.Orm.Common
{
    public class CommonUtils
    {
        ///

/// 用于字符串和枚举类型的转换
///

        ///
        ///
        ///
        public static T EnumParse<T>(string value)
        {
            try
            {
                return (T)Enum.Parse(typeof(T), value);
            }
            catch
            {
                throw new Exception("传入的值与枚举值不匹配。");
            }
        }

        ///

/// 根据传入的Key获取配置文件中的Value值
///

        ///
        ///
        public static string GetConfigValueByKey(string Key)
        {
            try
            {
                return ConfigurationManager.AppSettings[Key].ToString();
            }
            catch
            {
                throw new Exception("web.config中 Key=\"" + Key + "\"未配置或配置错误！");
            }
        }

        ///

/// 为实体类对象中的属性设置值
///

        /// 实体类对象
        /// 属性
        /// 需要设置的值
        public static void SetProperty(object obj,PropertyInfo property,object value)
        {
            //先获取该私有成员的数据类型
            Type type = property.PropertyType;

            //通过数据类型转换
            value = TypeUtils.ConvertForType(value, type);

            //将值设置到对象中
            property.SetValue(obj, value, null);
        }

        ///

/// 为实体类对象中的私有成员设置值
///

        /// 实体类对象
        /// 私有成员对象
        /// 需要设置的值
        public static void SetField(object obj, FieldInfo field, object value)
        {
            //先获取该私有成员的数据类型
            Type type = field.FieldType;

            //通过数据类型转换
            value = TypeUtils.ConvertForType(value, type);

            //将值设置到对象中
            field.SetValue(obj, value);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace System.Orm.DBUtility
{
    ///

/// 数据库类型枚举，需要扩展类型可在此添加
///

    public enum DatabaseType
    {
        SQLSERVER,
        ORACLE
    }
}

ITPub博客

自己编写简单易用的ASP.NET ORM 框架（转）

最新文章