我的数据库操作类EMESqlHelper

   在现在项目中,数据库操作类是必不可少.网络上也有很多开源的,我想大家比较熟悉的应该是sqlhelper,自己现在用的这份类也是参照网上的资料和以前同事代码中改了些,代码如下:

using System;
using System.Collections;
using System.Data;
using System.Data.SqlClient;
using System.Xml;
using System.Web;
using EMEFRAME.CallDataBase;

namespace EMEFRAME.CallDataBase
{
    /**//// <summary>
    /// EMESqlHelper 的摘要说明。
    /// </summary>
    public class EMESqlHelper: System.ComponentModel.Component
    {
        SqlDataBase sql = new SqlDataBase();
        /**//// <summary>
        /// Sql 连接字符串，一般情况下在APPLICATION START 中 初始化 联机串
        /// </summary>
        public static string CnConnectString = System.Configuration.ConfigurationSettings.AppSettings["ConnectionString"];


        构造函数 初始化连接字符串#region 构造函数 初始化连接字符串
        public EMESqlHelper()
        {
            sql.StrConnect = CnConnectString;
        }

        #endregion

        打开返回的事务#region 打开返回的事务
        public SqlTransaction OpenReturnTran()
        {
            return (SqlTransaction)sql.OpenAndReturnCn().BeginTransaction();
        }
        #endregion

        参数定义和转换#region 参数定义和转换

        /**//// <summary>
        /// 将字符串转为参数方向
        /// </summary>
        /// <param name="strDirection"></param>
        /// <returns></returns>
        private ParameterDirection ConvertStringToParameterDirection(string strDirection)
        {

            switch (strDirection.ToLower())
            {
                case "input":
                    return ParameterDirection.Input;
                case "output":
                    return ParameterDirection.Output;
                case "inputoutput":
                    return ParameterDirection.InputOutput;
                case "returnvalue":
                    return ParameterDirection.ReturnValue;
                default:
                    throw new Exception("数据房间获取错误");
            }
        }

        /**//// <summary>
        /// 将字符串转为SQL数据类型
        /// </summary>
        /// <param name="strParameterType"></param>
        /// <returns></returns>
        private SqlDbType ConvertStringToDataType(string strParameterType)
        {
            switch (strParameterType.ToLower())
            {
                case "bigint":
                    return SqlDbType.BigInt;
                case "binary":
                    return SqlDbType.Binary;
                case "bit":
                    return SqlDbType.Bit;
                case "char":
                    return SqlDbType.Char;
                case "datetime":
                    return SqlDbType.DateTime;
                case "numeric":
                    return SqlDbType.Float;
                case "float":
                    return SqlDbType.Float;
                case "image":
                    return SqlDbType.Image;
                case "int":
                    return SqlDbType.Int;
                case "money":
                    return SqlDbType.Money;
                case "nchar":
                    return SqlDbType.NChar;
                case "ntext":
                    return SqlDbType.NText;
                case "nvarchar":
                    return SqlDbType.NVarChar;
                case "real":
                    return SqlDbType.Real;
                case "smalldatetime":
                    return SqlDbType.SmallDateTime;
                case "smallint":
                    return SqlDbType.SmallInt;
                case "smallmoney":
                    return SqlDbType.SmallMoney;
                case "text":
                    return SqlDbType.Text;
                case "timestamp":
                    return SqlDbType.Timestamp;
                case "tinyint":
                    return SqlDbType.TinyInt;
                case "uniqueIdentifier":
                    return SqlDbType.UniqueIdentifier;
                case "varbinary":
                    return SqlDbType.VarBinary;
                case "varchar":
                    return SqlDbType.VarChar;
                case "variant":
                    return SqlDbType.Variant;
                case "decimal":
                    return SqlDbType.Decimal;
                default:
                    throw new Exception("数据类型获取失败");


            }
        }


        /**//// <summary>
        /// 将字符串转换为类型 枚举
        /// </summary>
        /// <returns></returns>
        private CommandType ConvertStringToCommandType(string strCmdType)
        {
            switch (strCmdType.ToLower())
            {
                case "storedprocedure":
                    return CommandType.StoredProcedure;
                case "text":
                    return CommandType.Text;
                case "tabledirect":
                    return CommandType.TableDirect;
                default:
                    throw new Exception("执行参数获取失败");
            }
        }
        #endregion
        无XML版本代码#region 无XML版本代码


        执行存储过程或者sql语句命令#region 执行存储过程或者sql语句命令
        /**//// <summary>
        /// 执行存储过程，需要返回参数时用 ,并且作为事务的一个部分
        /// </summary>
        /// <param name="sqlTran">事务过程</param>
        /// <param name="cmdText">SQL语句或存储过程名</param>
        /// <param name="cmdType">语句类型：0---SQL语句;1---存储过程</param>
        /// <param name="sqlpar">传入参数集合,无时为NULL</param>
        /// <param name="array">返回的参数集合，只需要传递一个ARRAYLIST对象，执行成功可返回所有的参数集合</param>
        public void ExecCommand(object sqlTran, string cmdText, string cmdType, object[] sqlpar, out ArrayList array)
        {
            try
            {
                if (cmdType == "0")
                {
                    sql.CmdType = CommandType.Text;
                }
                else
                {
                    sql.CmdType = CommandType.StoredProcedure;
                }
                sql.StrCommand = cmdText;
                if (sqlpar != null)
                    sql.SqlPar = (SqlParameter[])sqlpar;
                if (sqlTran != null)
                    sql.SalTrans = (SqlTransaction)sqlTran;
                sql.CmdExecNonQuery();
                array = new ArrayList();
                if (sqlpar != null)
                {
                    foreach (SqlParameter tmpsqlpar in sqlpar)
                    {
                        array.Add(tmpsqlpar.Value);
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
                //  throw new Exception("ExecuteNonQuery出错！");
            }
        }


        /**//// <summary>
        /// 执行Sql语句 或者 存储过程 并且作为事务过程提交
        /// </summary>
        /// <param name="sqlTran">事务过程</param>
        /// <param name="cmdText">SQL语句或存储过程名</param>
        /// <param name="cmdType">语句类型：0---SQL语句;1---存储过程</param>
        /// <param name="sqlpar">传入参数集合,无时为NULL</param>
        public void ExecCommand(object sqlTran, string cmdText, string cmdType, object[] sqlpar)
        {
            ArrayList array;
            ExecCommand(sqlTran, cmdText, cmdType, sqlpar, out array);
        }

        /**//// <summary>
        /// 执行Sql语句 或者 存储过程 并且作为事务过程提交
        /// </summary>
        /// <param name="sqlTran">事务过程</param>
        /// <param name="cmdText">SQL语句或存储过程名</param>
        /// <param name="cmdType">语句类型：0---SQL语句;1---存储过程</param>
        /// <param name="sqlpar">传入参数集合,无时为NULL</param>
        public void ExecCommand(object sqlTran, string cmdText, string cmdType)
        {
            ArrayList array;
            ExecCommand(sqlTran, cmdText, cmdType, null, out array);
        }

        /**//// <summary>
        /// 执行存储过程或SQL语句命令
        /// </summary>
        /// <param name="cmdText">SQL语句或存储过程名</param>
        /// <param name="cmdType">语句类型：0---SQL语句;1---存储过程</param>
        /// <param name="sqlpar">传入参数集合,无时为NULL</param>
        public void ExecCommand(string cmdText, string cmdType, object[] sqlpar)
        {
            ArrayList array;
            ExecCommand(null, cmdText, cmdType, sqlpar, out array);
        }

        /**//// <summary>
        /// 执行CMDSQL语句或者存储过程，需要返回参数时用
        /// </summary>
        /// <param name="cmdText">SQL语句或存储过程名</param>
        /// <param name="cmdType">语句类型：0---SQL语句;1---存储过程</param>
        /// <param name="sqlpar">传入参数集合,无时为NULL</param>
        /// <param name="array">返回的参数集合，只需要传递一个ARRAYLIST对象，执行成功可返回所有的参数集合</param>
        public void ExecCommand(string cmdText, string cmdType, object[] sqlpar, out ArrayList array)
        {
            ExecCommand(null, cmdText, cmdType, sqlpar, out array);
        }

        /**//// <summary>
        /// 执行CMDSQL语句或者存储过程
        /// </summary>
        /// <param name="cmdText">SQL语句或存储过程名</param>
        /// <param name="cmdType">语句类型：0---SQL语句;1---存储过程</param>
        public void ExecCommand(string cmdText, string cmdType)
        {
            ArrayList array;
            ExecCommand(null, cmdText, cmdType, null, out array);
        }
        #endregion

        执行带输出参数存储过程或者sql返回参数集合#region 执行带输出参数存储过程或者sql返回参数集合
        /**//// <summary>
        /// 执行存储过程 或者 SQL 语句命令 ，并且将参数集合返回
        /// </summary>
        /// <param name="cmdText">SQL语句或存储过程名</param>
        /// <param name="cmdType">语句类型：0---SQL语句;1---存储过程</param>
        /// <param name="sqlpar">参数集合</param>
        /// <returns>返回参数集合ArrayList</returns>
        public ArrayList GetReturnValue(string cmdText, string cmdType, object[] sqlpar)
        {
            ArrayList array;
            ExecCommand(null, cmdText, cmdType, sqlpar, out array);
            return array;
        }

        /**//// <summary>
        /// 执行存储过程 或者 SQL 语句命令 ，并且将参数集合返回
        /// </summary>
        /// <param name="cmdText">SQL语句或存储过程名</param>
        /// <param name="cmdType">语句类型：0---SQL语句;1---存储过程</param>
        /// <param name="sqlpar">参数集合</param>
        /// <returns>返回参数集合ArrayList</returns>
        public ArrayList GetReturnValue(string cmdText, string cmdType)
        {
            ArrayList array;
            ExecCommand(null, cmdText, cmdType, null, out array);
            return array;
        }
        #endregion

        执行存储过程或者sql返回 Dataset#region 执行存储过程或者sql返回 Dataset
        /**//// <summary>
        /// 执行存储过程 或者 SQL 语句命令 ，并且将参数集合返回
        /// </summary>
        /// <param name="sqlTran">事务过程</param>
        /// <param name="cmdText">SQL语句或存储过程名</param>
        /// <param name="cmdType">语句类型：0---SQL语句;1---存储过程</param>
        /// <param name="sqlpar">参数集合</param>
        /// <returns>返回Dataset数据集</returns>
        public DataSet GetDataSet(object sqlTran, string cmdText, string cmdType, object[] sqlpar, out ArrayList array)
        {
            try
            {
                if (cmdType == "0")
                {
                    sql.CmdType = CommandType.Text;
                }
                else
                {
                    sql.CmdType = CommandType.StoredProcedure;
                }
                sql.StrCommand = cmdText;
                if (sqlpar != null)
                {
                    sql.SqlPar = (SqlParameter[])sqlpar;
                    array = new ArrayList();
                    foreach (SqlParameter tmpsqlpar in sqlpar)
                    {
                        array.Add(tmpsqlpar.Value);
                    }
                }
                else
                {
                    array = new ArrayList();
                }
                if (sqlTran != null)
                {
                    sql.SalTrans = (SqlTransaction)sqlTran;
                }
                return sql.GetDataSet();
            }
            catch (Exception ex)
            {
                //throw new Exception("GetDataSet出错！");
                throw ex;
            }
        }

        /**//// <summary>
        /// 执行存储过程或SQL语句命令 
        /// </summary>
        /// <param name="cmdText">SQL语句或存储过程名</param>
        /// <param name="cmdType">语句类型：0---SQL语句;1---存储过程</param>
        /// <param name="sqlpar">参数集合</param>
        /// <returns>返回Dataset数据集</returns>
        public DataSet GetDataSet(object sqlTran, string cmdText, string cmdType, object[] sqlpar)
        {
            ArrayList array;
            return GetDataSet(sqlTran, cmdText, cmdType, sqlpar, out array);
        }

        /**//// <summary>
        /// 执行存储过程或SQL语句命令 
        /// </summary>
        /// <param name="cmdText">SQL语句或存储过程名</param>
        /// <param name="cmdType">语句类型：0---SQL语句;1---存储过程</param>
        /// <param name="sqlpar">参数集合</param>
        /// <returns>返回Dataset数据集</returns>
        public DataSet GetDataSet(string cmdText, string cmdType, object[] sqlpar)
        {
            ArrayList array;
            return GetDataSet(null, cmdText, cmdType, sqlpar, out array);
        }

        /**//// <summary>
        /// 执行存储过程或SQL语句命令 
        /// </summary>
        /// <param name="cmdText">SQL语句或存储过程名</param>
        /// <param name="cmdType">语句类型：0---SQL语句;1---存储过程</param>
        /// <param name="sqlpar">参数集合</param>
        /// <returns>返回Dataset数据集</returns>
        public DataSet GetDataSet(string cmdText, string cmdType)
        {
            ArrayList array;
            return GetDataSet(null, cmdText, cmdType, null, out array);
        }
        #endregion

        执行方式 返回 Reader#region 执行方式 返回 Reader
        /**//// <summary>
        /// 执行存储过程 或者 SQL 语句命令 ，并且返回Reader对象
        /// </summary>
        /// <param name="cmdText">SQL语句或存储过程名</param>
        /// <param name="cmdType">语句类型：0---SQL语句;1---存储过程</param>
        /// <param name="sqlpar">参数集合</param>
        /// <returns>返回Reader对象</returns>
        public IDataReader GetReader(string cmdText, string cmdType, object[] sqlpar)
        {
            try
            {
                if (cmdType == "0")
                {
                    sql.CmdType = CommandType.Text;
                }
                else
                {
                    sql.CmdType = CommandType.StoredProcedure;
                }
                sql.StrCommand = cmdText;
                if (sqlpar != null)
                {
                    sql.SqlPar = (SqlParameter[])sqlpar;
                }
                return sql.GetReader();
            }
            catch
            {
                throw new Exception("GetReader出错！");
            }
        }

        /**//// <summary>
        /// 执行存储过程 或者 SQL 语句命令 ，并且返回Reader对象
        /// </summary>
        /// <param name="cmdText">SQL语句或存储过程名</param>
        /// <param name="cmdType">语句类型：0---SQL语句;1---存储过程</param>
        /// <returns>返回Reader对象</returns>
        public IDataReader GetReader(string cmdText, string cmdType)
        {
            return GetReader(cmdText, cmdType, null);
        }
        #endregion

        执行命令 并且返回 首条记录的第一个字段#region 执行命令 并且返回 首条记录的第一个字段
        /**//// <summary>
        /// 执行存储过程 或者 SQL 语句命令 ，并且返回对应的有效第一个字段数据
        /// </summary>
        /// <param name="sqlTran">事务过程</param>
        /// <param name="cmdText">SQL语句或存储过程名</param>
        /// <param name="cmdType">语句类型：0---SQL语句;1---存储过程</param>
        /// <param name="sqlpar">参数集合</param>
        /// <returns>返回第一条记录的第一列字段</returns>
        public object ExecCommandScalar(object sqlTran, string cmdText, string cmdType, object[] sqlpar)
        {
            try
            {
                if (cmdType == "0")
                {
                    sql.CmdType = CommandType.Text;
                }
                else
                {
                    sql.CmdType = CommandType.StoredProcedure;
                }
                if (sqlTran != null)
                    sql.SalTrans = (SqlTransaction)sqlTran;
                if (sqlpar != null)
                {
                    sql.SqlPar = (SqlParameter[])sqlpar;
                }
                sql.StrCommand = cmdText;
                return sql.CmdExecScalar();
            }
            catch
            {
                throw new Exception("ExecCommandScalar出错！");
            }
        }


        /**//// <summary>
        /// 执行存储过程 或者 SQL 语句命令 ，并且返回对应的有效第一个字段数据
        /// </summary>
        /// <param name="cmdText">SQL语句或存储过程名</param>
        /// <param name="cmdType">语句类型：0---SQL语句;1---存储过程</param>
        /// <param name="sqlpar">参数集合</param>
        /// <returns>返回第一条记录的第一列字段</returns>
        public object ExecCommandScalar(string cmdText, string cmdType, SqlParameter[] sqlpar)
        {
            return ExecCommandScalar(null, cmdText, cmdType, sqlpar);
        }

        /**//// <summary>
        /// 执行存储过程 或者 SQL 语句命令 ，并且返回对应的有效第一个字段数据
        /// </summary>
        /// <param name="cmdText">SQL语句或存储过程名</param>
        /// <param name="cmdType">语句类型：0---SQL语句;1---存储过程</param>
        /// <returns>返回第一条记录的第一列字段</returns>
        public object ExecCommandScalar(string cmdText, string cmdType)
        {
            return ExecCommandScalar(null, cmdText, cmdType, null);
        }
        #endregion

        获得数据库表sId值最大值#region  获得数据库表sId值最大值
        /**//// <summary>
        /// 获得数据库表key值最大值
        /// </summary>
        /// <param name="key">key字段名称</param>
        /// <param name="sTable">表名或视图</param>
        /// <returns>返回string型（表中最大key值）</returns>
        public string GetMax(string key, string sTable)
        {
            return GetMax(key, sTable, "");
        }
        /**//// <summary>
        /// 获得数据库表key值最大值
        /// </summary>
        /// <param name="key字">key字段名称</param>
        /// <param name="sTable">表名或视图</param>
        /// <param name="sWhere">条件语句</param>
        /// <returns>返回string型（表中最大key值）</returns>
        public string GetMax(string key, string sTable, string sWhere)
        {
            try
            {
                sql.CmdType = CommandType.Text;
                sql.StrCommand = "select Max(" + key + ") from " + sTable + "  where 1=1 " + sWhere;
                return sql.CmdExecScalar().ToString();
            }
            catch
            {
                throw new Exception("GetMax出错！");
            }

        }
        #endregion

        获得记录总数#region 获得记录总数
        /**//// <summary>
        /// 获得表或视图满足条件的记录总数
        /// </summary>
        /// <param name="sTable">表名或视图</param>
        /// <param name="sWhere">条件语句</param>
        /// <returns>返回int型记录总数</returns>
        public int GetRecordCount(string sTable, string sWhere)
        {
            try
            {
                sql.CmdType = CommandType.Text;
                sql.StrCommand = "select count(*) from " + sTable + " where 1=1 " + sWhere;
                return (int)sql.CmdExecScalar();
            }
            catch (Exception ex)
            {
                throw ex;
                //throw new Exception("GetRecordCount出错！");
            }
        }

        /**//// <summary>
        /// 获得表或视图全部记录总数
        /// </summary>
        /// <param name="sTable">表或视图</param>
        /// <returns>返回int型记录总数</returns>
        public int GetRecordCount(string sTable)
        {
            return GetRecordCount(sTable, "");
        }
        #endregion

        #endregion

        protected override void Dispose(bool disposing)
        {
            sql.Disponse();
            base.Dispose(disposing);
        }
    }
}

调用例子:
1> 得到记录数
        /// <summary>
        /// 得到记录数
        /// </summary>
        /// <returns>返回int</returns>
        public static int getWB_SYS_UserCount(string sWhere)
        {
            int iCount = 0;
            try
            {
                using EMESqlHelper es = new EMESqlHelper())
                {
                    iCount = es.GetRecordCount("WB_SYS_User", sWhere);
                }
                return iCount;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
2> 带返回参数的存储过程调用(注意其中的InputOutput类型)
        /// <summary>
        /// 新增数据
        /// </summary>
        /// <param name="_obj">WB_SYS_UserEnt实体</param>
        /// <returns>返回bool值</returns>
        public static bool WB_SYS_UserAdd(WB_SYS_UserEnt _obj)
        {
            //*******************定义并赋值参数数组*******************//
            SqlParameter[] arParms = new SqlParameter[9];
            arParms[0] = new SqlParameter("AdminGroupID", SqlDbType.Int, 4);
            arParms[0].Direction = ParameterDirection.Input;
            arParms[0].Value = _obj.AdminGroupID;
            arParms[1] = new SqlParameter("Username", SqlDbType.NChar, 40);
            arParms[1].Direction = ParameterDirection.Input;
            arParms[1].Value = _obj.Username;
            arParms[2] = new SqlParameter("Password", SqlDbType.NChar, 64);
            arParms[2].Direction = ParameterDirection.Input;
            arParms[2].Value = _obj.Password;
            arParms[3] = new SqlParameter("RealName", SqlDbType.VarChar, 20);
            arParms[3].Direction = ParameterDirection.Input;
            arParms[3].Value = _obj.RealName;
            arParms[4] = new SqlParameter("MobileNum", SqlDbType.VarChar, 20);
            arParms[4].Direction = ParameterDirection.Input;
            arParms[4].Value = _obj.MobileNum;
            arParms[5] = new SqlParameter("PasswordAsk", SqlDbType.VarChar, 200);
            arParms[5].Direction = ParameterDirection.Input;
            arParms[5].Value = _obj.PasswordAsk;
            arParms[6] = new SqlParameter("PasswordAnswer", SqlDbType.VarChar, 200);
            arParms[6].Direction = ParameterDirection.Input;
            arParms[6].Value = _obj.PasswordAnswer;
            arParms[7] = new SqlParameter("Creater", SqlDbType.VarChar, 20);
            arParms[7].Direction = ParameterDirection.Input;
            arParms[7].Value = _obj.Creater;
            bool Exist = false;
            arParms[8] = new SqlParameter("Exist", SqlDbType.Bit, 1);
            arParms[8].Direction = ParameterDirection.InputOutput;
            arParms[8].Value = Exist;
            try
            {
                using EMESqlHelper es = new EMESqlHelper())
                {
                    es.ExecCommand("WB_SYS_User_Add", "1", arParms);
                    Exist = (bool)arParms[8].Value;
                }
                return !Exist;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
其中关联类SqlDataBase和DataBase的代码如下:

using System;
using System.Data;
using System.Data.SqlClient;

namespace EMEFRAME.CallDataBase
{
    /**//// <summary>
    /// SqlDataBase 的摘要说明。
    /// </summary>
    public class SqlDataBase : DataBase
    {
        数据属性#region 数据属性
        private string strConnect ;
        public string StrConnect
        {
            set {strConnect = value;}
        }

        private string strCommand;
        public string StrCommand 
        {
            set {strCommand =value;}
        }

        private CommandType cmdType;
        public CommandType CmdType 
        {
            set {cmdType =value ;}
        }    

        private SqlParameter [] sqlpar ;
        public SqlParameter [] SqlPar
        {
            set {sqlpar = value;}
        }

        private SqlTransaction sqlTrans;
        public SqlTransaction SalTrans
        {
            set {sqlTrans = value;}
        }

        SqlConnection cn = new SqlConnection();
        SqlCommand cmd = new SqlCommand(); 
        SqlDataReader reader = null;
        SqlDataAdapter adp = new SqlDataAdapter();        
        DataSet ds  =new DataSet();
        #endregion 
        public SqlDataBase()
        {
            //
            // TODO: 在此处添加构造函数逻辑
            //
        }

        打开数据库#region 打开数据库
        /**//// <summary>
        /// 打开数据库
        /// </summary>
        /// <returns></returns>
        public override bool OpenCn()
        {
            if (cn.State != ConnectionState.Open )
            {
                try
                {
                    cn.ConnectionString =    strConnect;                    
                    cn.Open ();                    
                    return true;
                }
                catch
                {
                    return false;
                }
            }
            else
                return true;
        }

        /**//// <summary>
        /// 打开并且返回SQLCONNECTION
        /// </summary>
        /// <returns></returns>
        public override IDbConnection OpenAndReturnCn()
        {
            if (cn.State != ConnectionState.Open )
            {
                try
                {
                    OpenCn();            
                    return cn;
                }
                catch
                {
                    return null;
                }
            }
            else
                return cn;
        }

        #endregion

        执行存储过程#region  执行存储过程
        /**//// <summary>
        /// 执行存储过程
        /// </summary>
        /// <returns>返回存储过程返回值</returns>
        public void RunProc() 
        {
            if (sqlTrans == null)
            {
                if (OpenCn())
                    cmd.Connection =cn;
                else
                    return ;
            }
            else
            {
                cmd.Transaction    = sqlTrans;
                cmd.Connection = sqlTrans.Connection;
            }
            cmd.CommandText =    strCommand;
            cmd.CommandType =    cmdType;
            if (sqlpar!=null)
            {
                foreach(SqlParameter Nsqlpar in sqlpar)
                {
                    cmd.Parameters.Add (Nsqlpar);
                }
            }
            try
            {
                cmd.ExecuteNonQuery();
            }
            catch (System.Exception e)
            {
                throw e;
            }
        }
        #endregion

        执行 CMD#region 执行 CMD 
        /**//// <summary>
        /// 执行cmd，不返回数据
        /// </summary>
        public override void CmdExecNonQuery()
        {
            if (sqlTrans == null)
            {
                if (OpenCn())
                    cmd.Connection =cn;
                else
                    return ;
            }
            else
            {
                cmd.Transaction    = sqlTrans;
                cmd.Connection = sqlTrans.Connection;
            }
            cmd.CommandText =    strCommand;
            cmd.CommandType =    cmdType;
            if (sqlpar!=null)
            {
                foreach(SqlParameter Nsqlpar in sqlpar)
                {
                    cmd.Parameters.Add (Nsqlpar);
                }
            }
            cmd.ExecuteNonQuery ();
        }

        public override object CmdExecScalar()
        {
            if (sqlTrans == null)
            {
                if (OpenCn())
                    cmd.Connection =cn;
                else
                    return null;
            }
            else
            {
                cmd.Transaction    = sqlTrans;
                cmd.Connection = sqlTrans.Connection;
            }
            cmd.CommandText =    strCommand;
            cmd.CommandType =    cmdType;
            if (sqlpar!=null)
            {
                foreach(SqlParameter Nsqlpar in sqlpar)
                {
                    cmd.Parameters.Add (Nsqlpar);
                }
            }
            return cmd.ExecuteScalar();
        }

        #endregion 

        返回DATASET#region 返回DATASET
        /**//// <summary>
        /// 返回DataSet
        /// </summary>
        /// <returns></returns>
        public override DataSet GetDataSet()
        {
            if (sqlTrans == null)
            {
                if (OpenCn())
                    cmd.Connection =cn;
                else
                    return null;
            }
            else
            {
                cmd.Transaction    = sqlTrans;
                cmd.Connection = sqlTrans.Connection;
            }
            cmd.CommandText =    strCommand;
            cmd.CommandType =    cmdType;
            if (sqlpar!=null)
            {
                foreach (SqlParameter Nsqlpar in sqlpar)
                {
                    cmd.Parameters.Add (Nsqlpar);
                }
            }        
            adp.SelectCommand = cmd ;
            ds.Clear ();
            adp.Fill (ds);
            return ds;
        }

        public override DataSet GetDataSet(string TableName)
        {
            if (OpenCn())
                cmd.Connection =cn;
            else
                return null;
            cmd.CommandText =    strCommand;
            cmd.CommandType =    cmdType;
            if (sqlpar!=null)
            {
                foreach (SqlParameter Nsqlpar in sqlpar)
                {
                    cmd.Parameters.Add (Nsqlpar);
                }
            }
            adp.SelectCommand = cmd ;
            ds.Clear();
            adp.Fill (ds,TableName);
            return ds;
        }

        #endregion 

        返回READER#region 返回READER 
        public override IDataReader GetReader()
        {
            if (OpenCn())
                cmd.Connection = cn;
            else
                return null;
            cmd.CommandText = strCommand ;
            cmd.CommandType =cmdType;
            if (sqlpar!=null)
            {
                foreach (SqlParameter Nsqlpar in sqlpar)
                {
                    cmd.Parameters.Add (Nsqlpar);
                }
            }
            try
            {
                reader = cmd.ExecuteReader ();
                return reader;
            }
            catch
            {
                return null;
            }
        }

        #endregion 

        卸载内存#region 卸载内存
        public override void ClearParameter()
        {
            cmd.Parameters.Clear();
        }

        public override void CloseReader()
        {
            if (reader != null)
                if (!reader.IsClosed)
                    reader.Close ();
        }

        public override void CloseCn()
        {
            if (cn != null && cn.State !=ConnectionState.Closed )
                cn.Close ();
        }

        public override void Disponse()
        {
            cmd.Dispose ();
            CloseReader();
            adp.Dispose ();
            ds.Dispose ();
            CloseCn();
            cn.Dispose ();
        }



        #endregion 


    }
}

using System;
using System.Data;

namespace EMEFRAME.CallDataBase
{
    /**//// <summary>
    /// DataBase 的摘要说明。
    /// </summary>
    public abstract class DataBase
    {
        public DataBase()
        {
        }

        public abstract bool OpenCn ();
        public abstract IDbConnection OpenAndReturnCn();
        public abstract IDataReader GetReader ();
        public abstract DataSet GetDataSet (string TableName);
        public abstract DataSet GetDataSet();
        public abstract void CmdExecNonQuery ();
        public abstract object CmdExecScalar ();
        public abstract void CloseCn ();
        public abstract void CloseReader ();
        public abstract void ClearParameter ();
        public abstract void Disponse ();
    }
}