Winform开发框架之存储过程的支持--存储过程的实现和演化提炼（2）

本篇继续上篇《Winform开发框架之存储过程的支持--存储过程的实现和演化提炼（1）》来对Winform开发框架之存储过程的支持进行介绍，上篇主要介绍了SQLServer和Oracle两种数据库对常规存储过程的编写和对比，本篇主要介绍如何在C#里面，如何对这些存储过程进行调用，并获取到对应的数据类型，如输出参数，单个数据记录，多个数据记录等情况。最后在完成实现功能的基础上，对这些实现进行演化提炼，并扩展到我的WInform开发框架里面，实现功能重用、代码简化的目的。

1、数据访问接口的定义

我们整个实例是以一个客户表T_Customer为例进行讲解的，整个表的框架支持代码，可以通过代码生成工具进行快速生成，生成后包括了IDAL、Entity、DALSQL、BLL层代码，然后可以利用代码进行测试存储过程是否执行成功等功能。

数据访问层的定义，依照框架的分层模式来处理，后面我们在增加DALOracle对Oracle数据库进行支持即可。

生成后数据访问层接口，他们通过基类接口继承的方式，已经具有了常规的增删改查、分页等系列接口，但是其他业务接口还是需要自己定义的，如数据访问接口成的定义如下所示。

namespace WHC.TestProject.IDAL
{
    /// <summary>
    /// 客户信息
    /// </summary>
    public interface ICustomer : IBaseDAL<CustomerInfo>
    {
    }
}

这里面的代码很简单，没有多余的代码行，那么里面究竟发生了什么呢，其中的IBaseDAL又是什么定义呢？

其实，IBaseDAL就是定义了很多我们开发用到的基础接口，如标准的增删改查，以及衍生出来的一些其他接口，如分页查询，条件查询等接口内容。这个ICustomer就是用来定义一些除了标准接口不能实现外的业务接口。

如果我们需要实现基于存储过程的接口，我们可能就需要增加一些接口定义，如下所示。

namespace WHC.TestProject.IDAL
{
    /// <summary>
    /// 客户信息
    /// </summary>
    public interface ICustomer : IBaseDAL<CustomerInfo>
    {
        #region 使用存储过程
        /// <summary>
        /// 使用存储过程插入数据
        /// </summary>
        /// <param name="info">实体对象</param>
        /// <returns></returns>
        bool StorePorc_Insert(CustomerInfo info, DbTransaction trans = null);

        /// <summary>
        /// 使用存储过程更新数据
        /// </summary>
        /// <param name="info">实体对象</param>
        /// <returns></returns>
        bool StorePorc_Update(CustomerInfo info, DbTransaction trans = null);

        /// <summary>
        /// 使用存储过程获取所有数据
        /// </summary>
        /// <returns></returns>
        List<CustomerInfo> StorePorc_GetAll(DbTransaction trans = null);

        /// <summary>
        /// 使用存储过程获取所有数据
        /// </summary>
        /// <returns></returns>
        DataTable StorePorc_GetAllToDataTable(DbTransaction trans = null);

        /// <summary>
        /// 使用存储过程，根据ID获取对应记录
        /// </summary>
        /// <param name="ID"></param>
        /// <returns></returns>
        CustomerInfo StorePorc_FindByID(string ID, DbTransaction trans = null);

        /// <summary>
        /// 使用存储过程，判断记录ID是否存在
        /// </summary>
        /// <param name="ID">记录ID</param>
        /// <returns></returns>
        bool StorePorc_ExistByID(string ID, DbTransaction trans = null);

        /// <summary>
        /// 使用存储过程，根据ID删除对应记录
        /// </summary>
        /// <param name="ID">记录ID</param>
        /// <returns></returns>
        bool StorePorc_DeleteByID(string ID, DbTransaction trans = null);

        /// <summary>
        /// 获取客户的最大年龄
        /// </summary>
        /// <returns></returns>
        int StorePorc_GetMaxAge();

        #endregion
    }

对于插入、更新和删除这样的操作，我们只需要返回它是否成功就可以了，那么它的接口实现应该是如何的呢？

2、SqlServer存储过程的调用实现

由于我们的Winform开发框架底层是利用微软企业库EnterpriseLibrary来访问数据的，那么对应这个企业库的使用存储过程的方法，也就是我们的实现了。

下面的代码就是它们对应的SqlServer实现了。

        public bool StorePorc_Insert(CustomerInfo info, DbTransaction trans = null)
        {
            string procName = "T_Customer_Insert";

            Database db = CreateDatabase();
            DbCommand command = db.GetStoredProcCommand(procName);

            db.AddInParameter(command, "@ID", DbType.String, info.ID);
            db.AddInParameter(command, "@Name", DbType.String, info.Name);
            db.AddInParameter(command, "@Age", DbType.Int32, info.Age);

            bool result = false;
            if (trans != null)
            {
                result = db.ExecuteNonQuery(command, trans) > ;
            }
            else
            {
                result = db.ExecuteNonQuery(command) > ;
            }
            return result;
        }

        public bool StorePorc_Update(CustomerInfo info, DbTransaction trans = null)
        {
            string procName = "T_Customer_UpdateByID";

            Database db = CreateDatabase();
            DbCommand command = db.GetStoredProcCommand(procName);

            db.AddInParameter(command, "@ID", DbType.String, info.ID);
            db.AddInParameter(command, "@Name", DbType.String, info.Name);
            db.AddInParameter(command, "@Age", DbType.Int32, info.Age);

            bool result = false;
            if (trans != null)
            {
                result = db.ExecuteNonQuery(command, trans) > ;
            }
            else
            {
                result = db.ExecuteNonQuery(command) > ;
            }
            return result;
        }

        public bool StorePorc_DeleteByID(string ID, DbTransaction trans = null)
        {
            string procName = "T_Customer_DeleteByID";

            Database db = CreateDatabase();
            DbCommand command = db.GetStoredProcCommand(procName);
            db.AddInParameter(command, "@ID", DbType.String, ID);

            bool result = false;
            if (trans != null)
            {
                result = db.ExecuteNonQuery(command, trans) > ;
            }
            else
            {
                result = db.ExecuteNonQuery(command) > ;
            }
            return result;
        }

对于有返回输出参数的值，我们的做法有些不同，不过最主要的还是最终获取它的输出参数值而已，代码如下所示。

        public bool StorePorc_ExistByID(string ID, DbTransaction trans = null)
        {
            bool result = false;
            string procName = "T_Customer_ExistByID";

            Database db = CreateDatabase();
            DbCommand command = db.GetStoredProcCommand(procName);
            db.AddInParameter(command, "@ID", DbType.String, ID);
            db.AddOutParameter(command, "@Exist", DbType.Int32, );//输出参数

            if (trans != null)
            {
                db.ExecuteNonQuery(command, trans);
            }
            else
            {
                db.ExecuteNonQuery(command);
            }

            int iExist = ;
            int.TryParse(db.GetParameterValue(command, "@Exist").ToString(), out iExist);

            result = iExist > ;
            return result;
        }

        public int StorePorc_GetMaxAge()
        {
            string procName = "T_Customer_MaxAge";

            Database db = CreateDatabase();
            DbCommand command = db.GetStoredProcCommand(procName);

            db.AddOutParameter(command, "@MaxAge", DbType.Int32, );//输出参数

            db.ExecuteNonQuery(command);

            int maxAge = ;
            int.TryParse(db.GetParameterValue(command, "@MaxAge").ToString(), out maxAge);

            return maxAge;
        }    

上面的代码，主要就是利用了AddOutParameter对输出参数的信息进行设置，输出参数的数据类型要和脚本里面的类型定义对应，它的AddOutParameter的size参数值，可以为0。

最后我们通过db.GetParameterValue(command, "@MaxAge")的方式获取它的输出参数的值，并返回即可。

最后一个例子是介绍如何通过代码调用，获得它的实体对象或者实体对象列表，以及DataTable集合对象的例子了，这个也相对不是很麻烦，参照框架里面的做法即可。

获取实体对象信息的代码如下所示。

        public CustomerInfo StorePorc_FindByID(string ID, DbTransaction trans = null)
        {
            string procName = "T_Customer_SelectByID";

            Database db = CreateDatabase();
            DbCommand command = db.GetStoredProcCommand(procName);
            db.AddInParameter(command, "@ID", DbType.String, ID);

            CustomerInfo entity = null;
            if (trans != null)
            {
                using (IDataReader dr = db.ExecuteReader(command, trans))
                {
                    if (dr.Read())
                    {
                        entity = DataReaderToEntity(dr);
                    }
                }
            }
            else
            {
                using (IDataReader dr = db.ExecuteReader(command))
                {
                    if (dr.Read())
                    {
                        entity = DataReaderToEntity(dr);
                    }
                }
            }
            return entity;
        }

获取集合的代码如下所示。

        public List<CustomerInfo> StorePorc_GetAll(DbTransaction trans = null)
        {
            string procName = "T_Customer_SelectAll";

            Database db = CreateDatabase();
            DbCommand command = db.GetStoredProcCommand(procName);

            List<CustomerInfo> list = new List<CustomerInfo>();
            CustomerInfo entity = null;
            if (trans != null)
            {
                using (IDataReader dr = db.ExecuteReader(command, trans))
                {
                    while (dr.Read())
                    {
                        entity = DataReaderToEntity(dr);
                        list.Add(entity);
                    }
                }
            }
            else
            {
                using (IDataReader dr = db.ExecuteReader(command))
                {
                    while (dr.Read())
                    {
                        entity = DataReaderToEntity(dr);
                        list.Add(entity);
                    }
                }
            }
            return list;
        }

        public DataTable StorePorc_GetAllToDataTable(DbTransaction trans = null)
        {
            string procName = "T_Customer_SelectAll";

            Database db = CreateDatabase();
            DbCommand command = db.GetStoredProcCommand(procName);

            DataTable dt = null;
            if (trans != null)
            {
                dt = db.ExecuteDataSet(command, trans).Tables[];
            }
            else
            {
                dt = db.ExecuteDataSet(command).Tables[];
            }
return dt;
        }

3、Oracle存储过程的调用实现

上面是基于SqlServer存储过程的调用，前面的一篇文章我们介绍了存储过程的Oracle定义，是增加了一个游标来进行记录行数据的处理的，不管对于单行记录，还是多行记录，都是用了游标的输出参数的，那么在客户端里面，使用EnterpriseLibrary，应该如何调用，并且不需要传入这个输出参数的呢，做法其实很类似，只是有一点差异而已。

我们先从最简单的Oracle存储过程调用案例开始，介绍如何调用插入、更新和删除操作的Oracle存储过程的调用。这里和SqlServer的类似，不同的是我们使用了p_前缀来定义参数（基于Oracle的通用脚本参数定义规则）。

        public bool StorePorc_Insert(CustomerInfo info, DbTransaction trans = null)
        {
            string procName = "T_Customer_Insert";

            Database db = CreateDatabase();
            DbCommand command = db.GetStoredProcCommand(procName);

            db.AddInParameter(command, "p_ID", DbType.String, info.ID);
            db.AddInParameter(command, "p_Name", DbType.String, info.Name);
            db.AddInParameter(command, "p_Age", DbType.Int32, info.Age);

            bool result = false;
            if (trans != null)
            {
                result = db.ExecuteNonQuery(command, trans) > ;
            }
            else
            {
                result = db.ExecuteNonQuery(command) > ;
            }
            return result;
        }
        public bool StorePorc_Update(CustomerInfo info, DbTransaction trans = null)
        {
            string procName = "T_Customer_UpdateByID";

            Database db = CreateDatabase();
            DbCommand command = db.GetStoredProcCommand(procName);

            db.AddInParameter(command, "p_ID", DbType.String, info.ID);
            db.AddInParameter(command, "p_Name", DbType.String, info.Name);
            db.AddInParameter(command, "p_Age", DbType.Int32, info.Age);

            bool result = false;
            if (trans != null)
            {
                result = db.ExecuteNonQuery(command, trans) > ;
            }
            else
            {
                result = db.ExecuteNonQuery(command) > ;
            }
            return result;
        }

Oracle输出外部参数的做法也和sqlServer类似，具体调用代码如下所示。

        public int StorePorc_GetMaxAge()
        {
            string procName = "T_Customer_MaxAge";

            Database db = CreateDatabase();
            DbCommand command = db.GetStoredProcCommand(procName);

            db.AddOutParameter(command, "p_MaxAge", DbType.Int32, 0);//输出参数

            db.ExecuteNonQuery(command);

            int maxAge = 0;
            int.TryParse(db.GetParameterValue(command, "p_MaxAge").ToString(), out maxAge);

            return maxAge;
        }  

其他的也就很类似，就不再一一赘述了，基本上和SqlServer的一致，我们节省篇幅，用来看看如何调用返回记录的查询接口。下面是对应的Oracle存储过程的调用代码

        public CustomerInfo StorePorc_FindByID(string ID, DbTransaction trans = null)
        {
            string procName = "T_Customer_SelectByID";

            Database db = CreateDatabase();
            DbCommand command = db.GetStoredProcCommand(procName);
            db.AddInParameter(command, "p_ID", DbType.String, ID);

            CustomerInfo entity = null;
            if (trans != null)
            {
                using (IDataReader dr = db.ExecuteReader(command, trans))
                {
                    if (dr.Read())
                    {
                        entity = DataReaderToEntity(dr);
                    }
                }
            }
            else
            {
                using (IDataReader dr = db.ExecuteReader(command))
                {
                    if (dr.Read())
                    {
                        entity = DataReaderToEntity(dr);
                    }
                }
            }
            return entity;
        }

返回多条记录的操作代码如下所示。

        public List<CustomerInfo> StorePorc_GetAll(DbTransaction trans = null)
        {
            string procName = "T_Customer_SelectAll";

            Database db = CreateDatabase();
            DbCommand command = db.GetStoredProcCommand(procName);

            List<CustomerInfo> list = new List<CustomerInfo>();
            CustomerInfo entity = null;
            if (trans != null)
            {
                using (IDataReader dr = db.ExecuteReader(command, trans))
                {
                    while (dr.Read())
                    {
                        entity = DataReaderToEntity(dr);
                        list.Add(entity);
                    }
                }
            }
            else
            {
                using (IDataReader dr = db.ExecuteReader(command))
                {
                    while (dr.Read())
                    {
                        entity = DataReaderToEntity(dr);
                        list.Add(entity);
                    }
                }
            }
            return list;
        }

看完上面两个对记录处理的接口，我们看到，还是对我们在Oracle存储过程里面定义的输出游标参数忽略处理，我们不需要对它进行传值，它好像是透明的，呵呵。

这样它的做法就和SqlServer个各个接口实现也都差不多的了。

下面的脚本是我们之前定义的Oracle存储过程脚本，方便对比参照一下调用的函数代码。

------------------------------------
--作者：伍华聪 http://wuhuacong.cnblogs.com
--创建时间：2014年11月27日
--功能描述：以字段ID为关键字，检索表中的数据
------------------------------------
 Create Or Replace Procedure T_Customer_SelectByID
 (
cur_OUT OUT MyCURSOR.cur_OUT  ,
     p_ID IN T_CUSTOMER.ID%TYPE
 )
 AS
 Begin
 OPEN cur_OUT FOR Select * from T_CUSTOMER Where ID = p_ID ;
 End;
 / 

4、业务逻辑层的实现

上面我们定义了数据访问接口，以及两种数据实现层，在框架里面会根据不同的数据库类型配置，然后从不同的数据库访问层构建对象的，业务逻辑层主要就是对他们的接口进行调用了，具体代码如下所示。

    /// <summary>
    /// 客户信息
    /// </summary>
    public class Customer : BaseBLL<CustomerInfo>
    {
        public Customer() : base()
        {
            base.Init(this.GetType().FullName, System.Reflection.Assembly.GetExecutingAssembly().GetName().Name);
        }

        /// <summary>
        /// 根据客户名称获取客户列表
        /// </summary>
        /// <param name="name">客户名称</param>
        /// <returns></returns>
        public List<CustomerInfo> FindByName(string name)
        {
            string condition = string.Format("Name like '%{0}%' ", name);
            return baseDal.Find(condition);
        }

        #region 使用存储过程
        public bool StorePorc_Insert(CustomerInfo info, DbTransaction trans = null)
        {
            ICustomer dal = baseDal as ICustomer;
            return dal.StorePorc_Insert(info, trans);
        }

        public bool StorePorc_Update(CustomerInfo info, DbTransaction trans = null)
        {
            ICustomer dal = baseDal as ICustomer;
            return dal.StorePorc_Update(info, trans);
        }

        public List<CustomerInfo> StorePorc_GetAll(DbTransaction trans = null)
        {
            ICustomer dal = baseDal as ICustomer;
            return dal.StorePorc_GetAll(trans);
        }

        public DataTable StorePorc_GetAllToDataTable(DbTransaction trans = null)
        {
            ICustomer dal = baseDal as ICustomer;
            return dal.StorePorc_GetAllToDataTable(trans);
        }

        public CustomerInfo StorePorc_FindByID(string ID, DbTransaction trans = null)
        {
            ICustomer dal = baseDal as ICustomer;
            return dal.StorePorc_FindByID(ID, trans);
        }

        public bool StorePorc_ExistByID(string ID, DbTransaction trans = null)
        {
            ICustomer dal = baseDal as ICustomer;
            return dal.StorePorc_ExistByID(ID, trans);
        }

        public bool StorePorc_DeleteByID(string ID, DbTransaction trans = null)
        {
            ICustomer dal = baseDal as ICustomer;
            return dal.StorePorc_DeleteByID(ID, trans);
        }

        public int StorePorc_GetMaxAge()
        {
            ICustomer dal = baseDal as ICustomer;
            return dal.StorePorc_GetMaxAge();
        }
        #endregion
    }

为了验证我们的实现是否能够正常处理，并顺利获取对应的对象或者集合，我们需要编写一些代码，用来对它进行测试。

测试的代码如下所示。

        /// <summary>
        /// 测试存储过程的插入、修改、返回实体类、返回实体类集合、返回DataTable对象、输出参数等接口
        /// </summary>
        private void btnTestStoreProc_Click(object sender, EventArgs e)
        {
            //定义一个实体类的数据
            CustomerInfo info = new CustomerInfo();
            info.Name = "测试名称";
            info.Age = ;

            //调用存储过程插入数据，并判断是否成功
            bool inserted = BLLFactory<Customer>.Instance.StorePorc_Insert(info);
            Debug.Assert(inserted);

            //调用存储过程，获取输出参数，获得最大年龄值
            int maxAge = BLLFactory<Customer>.Instance.StorePorc_GetMaxAge();
            Debug.Assert(maxAge > );

            //调用存储过程，修改客户名称
            info.Name = "修改名称";
            bool updated = BLLFactory<Customer>.Instance.StorePorc_Update(info);

            //调用存储过程，获取最新的实体类对象，并对比是否修改成功
            CustomerInfo newInfo = BLLFactory<Customer>.Instance.StorePorc_FindByID(info.ID);
            Debug.Assert(newInfo != null);
            Debug.Assert(newInfo.Name == info.Name);

            //调用存储过程，获取输出参数，判断指定ID记录是否存在
            bool exist = BLLFactory<Customer>.Instance.StorePorc_ExistByID(info.ID);
            Debug.Assert(exist);

            //调用存储过程，获取全部实体列表集合，判断实体类列表是否正确
            List<CustomerInfo> list = BLLFactory<Customer>.Instance.StorePorc_GetAll();
            Debug.Assert(list.Count > );

            //调用存储过程，获取DataTable对象，判断集合不为空
            DataTable dt = BLLFactory<Customer>.Instance.StorePorc_GetAllToDataTable();
            Debug.Assert(dt.Rows.Count > );

            //调用存储过程，执行删除操作，并判断是否成功了
            bool deleted = BLLFactory<Customer>.Instance.StorePorc_DeleteByID(info.ID);
            Debug.Assert(deleted);

            string result = "全部操作完成";
            Console.WriteLine(result);
            MessageUtil.ShowTips(result);
        }

5、具体测试和验证

为了对他们进行测试，我们需要分别对SqlServer和Oracle进行测试，然后才能确认我们的实现是正确的。

分别在SQLServer和Oracle上运行存储过程脚本，创建对应的数据库脚本，如下所示。

测试Winform小程序，会得到成功的标志，标识所有的断言全部通过。

6、框架基类的演化提炼

本来写到上面小节，应该就可以告一段落了，因为功能也已经完成了，而且还是支持了两种不同的数据库，说明我们的实现和原先的想法都是正确的。

但是，我从来不喜欢臃肿的代码，我们留心回头看看前面的代码，两种不同数据库的实现很多是相似的，即使对于同一个数据库（如SQLServer）的存储过程接口实现，他们还是有很多优化的地方，代码依旧不够精简和优化，本小节就是专门针对这些进行提炼和优化的。

前面的框架介绍文章，我们可以了解到，数据访问接口实现层和接口定义层一样，都有一个基类，如基于SqlServer实现的基类为BaseDALSQL，这个基于SqlServer的数据访问基类，它也是继承自一个超级基类（大多数的实现在这里）AbstractBaseDAL。他们之间的继承关系如下所示，最终我们把提炼好的内容，放到这个AbstractBaseDAL就可以了，这样各个子类都可以进行调用，实现存储过程的处理。

对于存储过程的实现，我们分析一下各个接口，可以看到，输入参数是可选的，因为有些接口不需要输出参数；输出参数也是可选的，有些接口也不需要输出参数，返回的记录类型主要有bool类型，实体类型，实体集合类型，DataTable类型这几种，当然虽然有年龄接口的整形，但是这个是通过输出参数来获得的。

我们于是可以定义一个类似这样的通用接口参数集合，用来处理需要返回是否成功获取带有输出参数的，事务对象的接口，如下所示。

        /// <summary>
        /// 执行存储过程，如果影响记录数，返回True，否则为False，修改并输出外部参数outParameters（如果有）。
        /// </summary>
        /// <param name="storeProcName">存储过程名称</param>
        /// <param name="inParameters">输入参数，可为空</param>
        /// <param name="outParameters">输出参数，可为空</param>
        /// <param name="trans">事务对象，可为空</param>
        /// <returns>如果影响记录数，返回True，否则为False</returns>
        public bool StorePorcExecute(string storeProcName, Hashtable inParameters = null, Hashtable outParameters = null, DbTransaction trans = null)

它的实现基本上就是分为了几部分，第一部分是传入参数值（包括输入参数、输出参数的值），第二部是执行存储过程，三部分是获得输出参数并修改值即可。

具体的实现代码如下所示。

        /// <summary>
        /// 执行存储过程，如果影响记录数，返回True，否则为False，修改并输出外部参数outParameters（如果有）。
        /// </summary>
        /// <param name="storeProcName">存储过程名称</param>
        /// <param name="inParameters">输入参数，可为空</param>
        /// <param name="outParameters">输出参数，可为空</param>
        /// <param name="trans">事务对象，可为空</param>
        /// <returns>如果影响记录数，返回True，否则为False</returns>
        public bool StorePorcExecute(string storeProcName, Hashtable inParameters = null, Hashtable outParameters = null, DbTransaction trans = null)
        {
            Database db = CreateDatabase();
            DbCommand command = db.GetStoredProcCommand(storeProcName);
            //参数传入
            SetStoreParameters(db, command, inParameters, outParameters);

            //获取执行结果
            bool result = false;
            if (trans != null)
            {
                result = db.ExecuteNonQuery(command, trans) > ;
            }
            else
            {
                result = db.ExecuteNonQuery(command) > ;
            }

            //获取输出参数的值
            EditOutParameters(db, command, outParameters);

            return result;
        }

上面两部分红色哪里，因为他们在很多其他函数里面也通用，所以我就抽离作为一个私有函数了，就是传入参数，和传出结果的两部分。

由于输入输出参数都是可选的，因为我们不确定它是否存在值，所以我们分别对它进行了一定的处理，具体两个函数的代码如下所示。

        /// <summary>
        /// 传入输入参数和输出参数到Database和DbCommand对象。
        /// </summary>
        /// <param name="db">Database对象</param>
        /// <param name="command">DbCommand对象</param>
        /// <param name="inParameters">输入参数的哈希表</param>
        /// <param name="outParameters">输出参数的哈希表</param>
        private void SetStoreParameters(Database db, DbCommand command, Hashtable inParameters = null, Hashtable outParameters = null)
        {
            #region 参数传入
            //传入输入参数
            if (inParameters != null)
            {
                foreach (string param in inParameters.Keys)
                {
                    object value = inParameters[param];
                    db.AddInParameter(command, param, TypeToDbType(value.GetType()), value);
                }
            }

            //传入输出参数
            if (outParameters != null)
            {
                foreach (string param in outParameters.Keys)
                {
                    object value = outParameters[param];
                    db.AddOutParameter(command, param, TypeToDbType(value.GetType()), );//size统一设置为0
                }
            }
            #endregion
        }
        /// <summary>
        /// 执行存储过程后，获取需要输出的参数值，修改存储在哈希表里
        /// </summary>
        /// <param name="db">Database对象</param>
        /// <param name="command">DbCommand对象</param>
        /// <param name="outParameters">输出参数的哈希表</param>
        private void EditOutParameters(Database db, DbCommand command, Hashtable outParameters = null)
        {
            #region 获取输出参数的值
            if (outParameters != null)
            {
                ArrayList keys = new ArrayList(outParameters.Keys);//使用临时集合对象，避免迭代错误
                foreach (string param in keys)
                {
                    object retValue = db.GetParameterValue(command, param);

                    object value = outParameters[param];
                    outParameters[param] = Convert.ChangeType(retValue, value.GetType());
                }
            }
            #endregion
        }

这样我们就完成了一个普通存储过程该接口的通用处理了，但是我们知道，还有返回列表对象，列表集合，DataTable对象的几种不同方式，我们也应该要对他们进行一定的封装处理，已达到在子类能够很好使用的目的。

下面我把整个对这几部分封装的代码进行公布，它们的封装的代码如下所示（记得是放在超级抽象类上AbstractBaseDAL即可。

        #region 存储过程执行通用方法

        /// <summary>
        /// 执行存储过程，如果影响记录数，返回True，否则为False，修改并输出外部参数outParameters（如果有）。
        /// </summary>
        /// <param name="storeProcName">存储过程名称</param>
        /// <param name="inParameters">输入参数，可为空</param>
        /// <param name="outParameters">输出参数，可为空</param>
        /// <param name="trans">事务对象，可为空</param>
        /// <returns>如果影响记录数，返回True，否则为False</returns>
        public bool StorePorcExecute(string storeProcName, Hashtable inParameters = null, Hashtable outParameters = null, DbTransaction trans = null)
        {
            Database db = CreateDatabase();
            DbCommand command = db.GetStoredProcCommand(storeProcName);
            //参数传入
            SetStoreParameters(db, command, inParameters, outParameters);

            //获取执行结果
            bool result = false;
            if (trans != null)
            {
                result = db.ExecuteNonQuery(command, trans) > ;
            }
            else
            {
                result = db.ExecuteNonQuery(command) > ;
            }

            //获取输出参数的值
            EditOutParameters(db, command, outParameters);

            return result;
        }

        /// <summary>
        /// 执行存储过程，返回实体列表集合，修改并输出外部参数outParameters（如果有）。
        /// </summary>
        /// <param name="storeProcName">存储过程名称</param>
        /// <param name="inParameters">输入参数，可为空</param>
        /// <param name="outParameters">输出参数，可为空</param>
        /// <param name="trans">事务对象，可为空</param>
        /// <returns>返回实体列表集合</returns>
        public List<T> StorePorcToList(string storeProcName, Hashtable inParameters = null, Hashtable outParameters = null, DbTransaction trans = null)
        {
            Database db = CreateDatabase();
            DbCommand command = db.GetStoredProcCommand(storeProcName);
            //参数传入
            SetStoreParameters(db, command, inParameters, outParameters);

            #region 获取执行结果

            List<T> result = new List<T>();
            T entity = null;
            if (trans != null)
            {
                using (IDataReader dr = db.ExecuteReader(command, trans))
                {
                    while (dr.Read())
                    {
                        entity = DataReaderToEntity(dr);
                        result.Add(entity);
                    }
                }
            }
            else
            {
                using (IDataReader dr = db.ExecuteReader(command))
                {
                    while (dr.Read())
                    {
                        entity = DataReaderToEntity(dr);
                        result.Add(entity);
                    }
                }
            }
            #endregion

            //获取输出参数的值
            EditOutParameters(db, command, outParameters);

            return result;
        }

        /// <summary>
        /// 执行存储过程，返回DataTable集合，修改并输出外部参数outParameters（如果有）。
        /// </summary>
        /// <param name="storeProcName">存储过程名称</param>
        /// <param name="inParameters">输入参数，可为空</param>
        /// <param name="outParameters">输出参数，可为空</param>
        /// <param name="trans">事务对象，可为空</param>
        /// <returns>返回DataTable集合</returns>
        public DataTable StorePorcToDataTable(string storeProcName, Hashtable inParameters = null, Hashtable outParameters = null, DbTransaction trans = null)
        {
            Database db = CreateDatabase();
            DbCommand command = db.GetStoredProcCommand(storeProcName);
            //参数传入
            SetStoreParameters(db, command, inParameters, outParameters);

            #region 获取执行结果

            DataTable result = null;
            if (trans != null)
            {
                result = db.ExecuteDataSet(command, trans).Tables[];
            }
            else
            {
                result = db.ExecuteDataSet(command).Tables[];
            }

            if (result != null)
            {
                result.TableName = "tableName";//增加一个表名称，防止WCF方式因为TableName为空出错
            }
            #endregion

            //获取输出参数的值
            EditOutParameters(db, command, outParameters);

            return result;
        }

        /// <summary>
        /// 执行存储过程，返回实体对象，修改并输出外部参数outParameters（如果有）。
        /// </summary>
        /// <param name="storeProcName">存储过程名称</param>
        /// <param name="inParameters">输入参数，可为空</param>
        /// <param name="outParameters">输出参数，可为空</param>
        /// <param name="trans">事务对象，可为空</param>
        /// <returns>返回实体对象</returns>
        public T StorePorcToEntity(string storeProcName, Hashtable inParameters = null, Hashtable outParameters = null, DbTransaction trans = null)
        {
            Database db = CreateDatabase();
            DbCommand command = db.GetStoredProcCommand(storeProcName);

            //参数传入
            SetStoreParameters(db, command, inParameters, outParameters);

            #region 获取执行结果

            T result = null;
            if (trans != null)
            {
                using (IDataReader dr = db.ExecuteReader(command, trans))
                {
                    if (dr.Read())
                    {
                        result = DataReaderToEntity(dr);
                    }
                }
            }
            else
            {
                using (IDataReader dr = db.ExecuteReader(command))
                {
                    if (dr.Read())
                    {
                        result = DataReaderToEntity(dr);
                    }
                }
            }
            #endregion

            //获取输出参数的值
            EditOutParameters(db, command, outParameters);

            return result;
        }

        /// <summary>
        /// 传入输入参数和输出参数到Database和DbCommand对象。
        /// </summary>
        /// <param name="db">Database对象</param>
        /// <param name="command">DbCommand对象</param>
        /// <param name="inParameters">输入参数的哈希表</param>
        /// <param name="outParameters">输出参数的哈希表</param>
        private void SetStoreParameters(Database db, DbCommand command, Hashtable inParameters = null, Hashtable outParameters = null)
        {
            #region 参数传入
            //传入输入参数
            if (inParameters != null)
            {
                foreach (string param in inParameters.Keys)
                {
                    object value = inParameters[param];
                    db.AddInParameter(command, param, TypeToDbType(value.GetType()), value);
                }
            }

            //传入输出参数
            if (outParameters != null)
            {
                foreach (string param in outParameters.Keys)
                {
                    object value = outParameters[param];
                    db.AddOutParameter(command, param, TypeToDbType(value.GetType()), );//size统一设置为0
                }
            }
            #endregion
        }
        /// <summary>
        /// 执行存储过程后，获取需要输出的参数值，修改存储在哈希表里
        /// </summary>
        /// <param name="db">Database对象</param>
        /// <param name="command">DbCommand对象</param>
        /// <param name="outParameters">输出参数的哈希表</param>
        private void EditOutParameters(Database db, DbCommand command, Hashtable outParameters = null)
        {
            #region 获取输出参数的值
            if (outParameters != null)
            {
                ArrayList keys = new ArrayList(outParameters.Keys);//使用临时集合对象，避免迭代错误
                foreach (string param in keys)
                {
                    object retValue = db.GetParameterValue(command, param);

                    object value = outParameters[param];
                    outParameters[param] = Convert.ChangeType(retValue, value.GetType());
                }
            }
            #endregion
        }
        #endregion

封装好这些超级基类后，我们在数据访问层里面，就可以很好地简化对存储过程的调用了，而且他们的做法都很类似，我们可以对比一下，它们调用存储过程的实现真正简化了很多。

例如对于SqlServer数据访问层，使用超级基类的接口，我们简化代码如下所示。

        public bool StorePorc_Insert(CustomerInfo info, DbTransaction trans = null)
        {
            Hashtable inParameters = new Hashtable();
            inParameters.Add("ID", info.ID);
            inParameters.Add("Name", info.Name);
            inParameters.Add("Age", info.Age);

            return StorePorcExecute("T_Customer_Insert", inParameters, null, trans);
        }

        public bool StorePorc_Update(CustomerInfo info, DbTransaction trans = null)
        {
            Hashtable inParameters = new Hashtable();
            inParameters.Add("ID", info.ID);
            inParameters.Add("Name", info.Name);
            inParameters.Add("Age", info.Age);

            return StorePorcExecute("T_Customer_UpdateByID", inParameters, null, trans);
        }

        public List<CustomerInfo> StorePorc_GetAll(DbTransaction trans = null)
        {
            return StorePorcToList("T_Customer_SelectAll", null, null, trans);
        }
        public DataTable StorePorc_GetAllToDataTable(DbTransaction trans = null)
        {
            return StorePorcToDataTable("T_Customer_SelectAll", null, null, trans);
        }
        public CustomerInfo StorePorc_FindByID(string ID, DbTransaction trans = null)
        {
            Hashtable inParameters = new Hashtable();
            inParameters.Add("ID", ID);

            return StorePorcToEntity("T_Customer_SelectByID", inParameters, null, trans);
        }
        public bool StorePorc_ExistByID(string ID, DbTransaction trans = null)
        {
            Hashtable inParameters = new Hashtable();
            inParameters.Add("ID", ID);

            Hashtable outParameters = new Hashtable();
            outParameters.Add("Exist", );

            StorePorcExecute("T_Customer_ExistByID", inParameters, outParameters, trans);
            int exist = (int)outParameters["Exist"];
            return exist > ;
        }

        public bool StorePorc_DeleteByID(string ID, DbTransaction trans = null)
        {
            Hashtable inParameters = new Hashtable();
            inParameters.Add("ID", ID);

            return StorePorcExecute("T_Customer_DeleteByID", inParameters, null, trans);
        }

        public int StorePorc_GetMaxAge()
        {
            Hashtable outParameters = new Hashtable();
            outParameters.Add("MaxAge", );

            StorePorcExecute("T_Customer_MaxAge", null, outParameters, null);
            int MaxAge = (int)outParameters["MaxAge"];
            return MaxAge;
        }

对于Oracle数据访问层的实现来说，它的接口实现一样简单，只是参数命名有所不同而已。

        public bool StorePorc_Insert(CustomerInfo info, DbTransaction trans = null)
        {
            Hashtable inParameters = new Hashtable();
            inParameters.Add("p_ID", info.ID);
            inParameters.Add("p_Name", info.Name);
            inParameters.Add("p_Age", info.Age);

            return StorePorcExecute("T_Customer_Insert", inParameters, null, trans);
        }
        public bool StorePorc_Update(CustomerInfo info, DbTransaction trans = null)
        {
            Hashtable inParameters = new Hashtable();
            inParameters.Add("p_ID", info.ID);
            inParameters.Add("p_Name", info.Name);
            inParameters.Add("p_Age", info.Age);

            return StorePorcExecute("T_Customer_UpdateByID", inParameters, null, trans);
        }
        public List<CustomerInfo> StorePorc_GetAll(DbTransaction trans = null)
        {
            return StorePorcToList("T_Customer_SelectAll", null, null, trans);
        }
        public DataTable StorePorc_GetAllToDataTable(DbTransaction trans = null)
        {
            return StorePorcToDataTable("T_Customer_SelectAll", null, null, trans);
        }
        public CustomerInfo StorePorc_FindByID(string ID, DbTransaction trans = null)
        {
            Hashtable inParameters = new Hashtable();
            inParameters.Add("p_ID", ID);

            return StorePorcToEntity("T_Customer_SelectByID", inParameters, null, trans);
        }
        public bool StorePorc_ExistByID(string ID, DbTransaction trans = null)
        {
            Hashtable inParameters = new Hashtable();
            inParameters.Add("p_ID", ID);

            Hashtable outParameters = new Hashtable();
            outParameters.Add("p_Exist", );

            StorePorcExecute("T_Customer_ExistByID", inParameters, outParameters, trans);
            int exist = (int)outParameters["p_Exist"];
            return exist > ;
        }

        public bool StorePorc_DeleteByID(string ID, DbTransaction trans = null)
        {
            Hashtable inParameters = new Hashtable();
            inParameters.Add("p_ID", ID);

            return StorePorcExecute("T_Customer_DeleteByID", inParameters, null, trans);
        }

        public int StorePorc_GetMaxAge()
        {
            Hashtable outParameters = new Hashtable();
            outParameters.Add("p_MaxAge", );

            StorePorcExecute("T_Customer_MaxAge", null, outParameters, null);
            int MaxAge = (int)outParameters["p_MaxAge"];
            return MaxAge;
        }

以上就是我针对《Winform开发框架之存储过程的支持--存储过程的实现和演化提炼》这个主题进行的介绍和分析，希望对大家有所帮助，也希望结合我的框架，迅速开发各种不同的项目。

文章内容有点长，感谢您的耐心阅读和支持。

Winform开发框架之存储过程的支持--存储过程的实现和演化提炼（1）

Winform开发框架之存储过程的支持--存储过程的实现和演化提炼（2）