最近一边参与公司的项目开发，一边还肩负着基础库的创建和维护。真真切切的体会到写框架的不容易，写出好的，方便使用的框架更不容易，需要考虑的东西太多，需要掌握的东西太多。不过不要紧我们正在前进的道路上。同志们一起加油！

经过与DBA的沟通，他认为对存储过程的封装是有必要的，以他十几年的经验看，存储过程后期的移植是必不可少的。现在的项目是用SQLSERVER2008开发的，后期可能会移植到ORACLE上去，那么对存储过程的编写DBA考虑很周全。但是对于程序员来说，经验稍微丰富点的可能会通过某种工厂将具体对象脱耦，或者使用依赖倒置的原则来解决更换数据源问题。但是考虑到统一的使用方法，这里还是真的有必要进行封装的。那么如何封装？

1. Dictionary<string, object> parameter = new Dictionary<string, object>();  
2. parameter.Add("PurchaseID", Purchase.TempSerialNo);//单据流水号   
3. parameter.Add("WarehouseId", Purchase.InWarehouseID);//仓库ID  
4. parameter.Add("UserID", Purchase.UserID);//操作ID  
5. parameter.Add("UserName", Purchase.UserName);//操作人名称  
6. parameter.Add("PurchaseDate", DBNull.Value);//采购日期  
7. parameter.Add("BuyUserID", DBNull.Value);//采购人编号  
8. parameter.Add("BuyUserName", DBNull.Value);//采购人名称  
9. parameter.Add("BuyDate", DBNull.Value);//采购日期  
10. parameter.Add("Memo", Purchase.Memo);//备注说明  
11. IDataParameter[] parameterDic = IDataParameterFactory.CreateDbDataParameter(parameter);  
12.  List<IDataParameter> listparameter = IDataParameterHelper.IDataParameterArrayToList(parameterDic);  
13. listparameter.Add(WL.DAL.DAL_TB_WLPurchase.GetErrIDParametere());  
14. using (Fast.Orm.IDataSourceOperation operation = Fast.Orm.IDataSourceOperationFactory.Create())  
15. {  
16. operation.ExecuteNonQuery(CommandType.StoredProcedure, "prc_WLPurchaseTmpAdd", listparameter.ToArray());  
17. if (listparameter[listparameter.Count - 1].Value.ToString() == "0")  
18. return true;  
19. return false;  
20. }  

 

一般性的封装基本都这样或者在IDataParameterFactory.CreateDbDataParameter(Entity)中加入根据实体的属性动态的创建IDataParameter[]对象，如果你的创建始终是使用反射的话那么将是不可取的。有兴趣的朋友可以参见本人的另一篇文章“”对实体的使用如果不能摆脱反射，那么在以后的基础库扩展中将面临着很多性能问题，这里需三思。

1. /// <summary>  
2.     /// 存储过程实体（参数信息类）基类  
3.     /// </summary>  
4.     public abstract class BaseStoredprocedureObject : DictionaryBase  
5.     {  
6.         /// <summary>  
7.         /// 受保护的字段-存储过程名称  
8.         /// </summary>  
9.         protected string procedurename = string.Empty;  
10.         /// <summary>  
11.         /// 受保护的字段-命令参数集合  
12.         /// </summary>  
13.         protected List<IDataParameter> parameterlist = new List<IDataParameter>();  
14.         /// <summary>  
15.         /// 获取命令参数集合  
16.         /// </summary>  
17.         public List<IDataParameter> ParameterList  
18.         {  
19.             get { return parameterlist; }  
20.         }  
21.         /// <summary>  
22.         /// 添加IDataParameter对象到基类parameterlist对象  
23.         /// </summary>  
24.         public abstract void AddParameterToBaseParameterObject();  
25.         /// <summary>  
26.         /// 获取存储过程名称  
27.         /// </summary>  
28.         public string ProcedureName  
29.         {  
30.             get { return procedurename; }  
31.         }  
32.         /// <summary>  
33.         /// 获取对应参数名称的值  
34.         /// </summary>  
35.         /// <param name="keyname">参数名称</param>  
36.         /// <returns>object：参数值</returns>  
37.         public object this[string keyname]  
38.         {  
39.             get { return this.Dictionary[keyname]; }  
40.             internal set { this.Dictionary[keyname] = value; }  
41.         }  
42.         /// <summary>  
43.         /// 获取所有参数信息  
44.         /// </summary>  
45.         public IDictionary GetProcedureEntity  
46.         {  
47.             get { return this.Dictionary; }  
48.         }  
49.         /// <summary>  
50.         /// 存储过程返回的数据集  
51.         /// </summary>  
52.         public DataTable Source  
53.         {  
54.             get;  
55.             internal set;  
56.         }  
57. }  

1. using System;  
2. using System.Collections.Generic;  
3. using System.Text;  
4. using System.Data;  
5. using Fast.Orm;  
6.  
7. namespace Fast.WL.Parmeter  
8. {  
9.     [Serializable()]  
10.     public class Init_prc_WLOrderTmpAdd : BaseStoredprocedureObject  
11.     {  
12.         public Init_prc_WLOrderTmpAdd()  
13.         {  
14.             this.procedurename = "prc_WLOrderTmpAdd";  
15.             this.Dictionary.Add("OrderID", null);  
16.             this.Dictionary.Add("StationID", null);  
17.             this.Dictionary.Add("UserID", null);  
18.             this.Dictionary.Add("UserName", null);  
19.             this.Dictionary.Add("OrderDate", null);  
20.             this.Dictionary.Add("DeliveryAddress", null);  
21.             this.Dictionary.Add("OrderType", null);  
22.             this.Dictionary.Add("APNumber", null);  
23.             this.Dictionary.Add("Memo", null);  
24.             this.Dictionary.Add("ErrID", DBNull.Value);  
25.         }  
26.         public override void AddParameterToBaseParameterObject()  
27.         {  
28.             base.parameterlist.Add(IDataParameterFactory.CreateDbDataParameter(  
29. "OrderID", base.Dictionary["OrderID"],  
30. ParameterDirection.Input, DbType.String, 14));  
31.             base.parameterlist.Add(IDataParameterFactory.CreateDbDataParameter(  
32. "StationID", base.Dictionary["StationID"],  
33. ParameterDirection.Input, DbType.String, 36));  
34.             base.parameterlist.Add(IDataParameterFactory.CreateDbDataParameter(  
35. "UserID", base.Dictionary["UserID"],  
36. ParameterDirection.Input, DbType.String, 36));  
37.             base.parameterlist.Add(IDataParameterFactory.CreateDbDataParameter(  
38. "UserName", base.Dictionary["UserName"],  
39. ParameterDirection.Input, DbType.String, 10));  
40.             base.parameterlist.Add(IDataParameterFactory.CreateDbDataParameter(  
41. "OrderDate", base.Dictionary["OrderDate"],  
42. ParameterDirection.Input, DbType.DateTime, 8));  
43.             base.parameterlist.Add(IDataParameterFactory.CreateDbDataParameter(  
44. "DeliveryAddress", base.Dictionary["DeliveryAddress"],  
45. ParameterDirection.Input, DbType.String, 50));  
46.             base.parameterlist.Add(IDataParameterFactory.CreateDbDataParameter(  
47. "OrderType", base.Dictionary["OrderType"],  
48. ParameterDirection.Input, DbType.Int16, 2));  
49.             base.parameterlist.Add(IDataParameterFactory.CreateDbDataParameter(  
50. "APNumber", base.Dictionary["APNumber"],  
51. ParameterDirection.Input, DbType.String, 20));  
52.             base.parameterlist.Add(IDataParameterFactory.CreateDbDataParameter(  
53. "Memo", base.Dictionary["Memo"],  
54. ParameterDirection.Input, DbType.String, 220));  
55.             base.parameterlist.Add(IDataParameterFactory.CreateDbDataParameter(  
56. "ErrID", base.Dictionary["ErrID"],  
57. ParameterDirection.Output, DbType.Int32, 4));  
58.         }  
59.     }  
60.     public class prc_WLOrderTmpAdd : Init_prc_WLOrderTmpAdd  
61.     {  
62.         public object OrderID  
63.         {  
64.             get { return this.Dictionary["OrderID"] as object; }  
65.             set { this.Dictionary["OrderID"] = value; }  
66.         }  
67.         public object StationID  
68.         {  
69.             get { return this.Dictionary["StationID"] as object; }  
70.             set { this.Dictionary["StationID"] = value; }  
71.         }  
72.         public object UserID  
73.         {  
74.             get { return this.Dictionary["UserID"] as object; }  
75.             set { this.Dictionary["UserID"] = value; }  
76.         }  
77.         public object UserName  
78.         {  
79.             get { return this.Dictionary["UserName"] as object; }  
80.             set { this.Dictionary["UserName"] = value; }  
81.         }  
82.         public object OrderDate  
83.         {  
84.             get { return this.Dictionary["OrderDate"] as object; }  
85.             set { this.Dictionary["OrderDate"] = value; }  
86.         }  
87.         public object DeliveryAddress  
88.         {  
89.             get { return this.Dictionary["DeliveryAddress"] as object; }  
90.             set { this.Dictionary["DeliveryAddress"] = value; }  
91.         }  
92.         public object OrderType  
93.         {  
94.             get { return this.Dictionary["OrderType"] as object; }  
95.             set { this.Dictionary["OrderType"] = value; }  
96.         }  
97.         public object APNumber  
98.         {  
99.             get { return this.Dictionary["APNumber"] as object; }  
100.             set { this.Dictionary["APNumber"] = value; }  
101.         }  
102.         public object Memo  
103.         {  
104.             get { return this.Dictionary["Memo"] as object; }  
105.             set { this.Dictionary["Memo"] = value; }  
106.         }  
107.         public object ErrID  
108.         {  
109.             get { return this.Dictionary["ErrID"] as object; }  
110.             set { this.Dictionary["ErrID"] = value; }  
111.         }  
112.     }  
113. }  

在Init_prc_WLOrderTmpAdd构造函数中我们设置所有的参数名称和默认的值，这里可以会是DbNull.Value。[王清培版权所有，转载请给出署名]

1. prc_WLOrderTmpAdd ordertmp = new prc_WLOrderTmpAdd();  
2.                 ordertmp.OrderID = order.OrderID;//订单流水号  
3.                 ordertmp.StationID = order.StationID;//站点ID  
4.                 ordertmp.UserID = order.UserID;  
5.                 ordertmp.UserName = order.UserName;  
6.                 ordertmp.OrderDate = DBNull.Value;  
7.                 ordertmp.DeliveryAddress = order.DeliveryAddress;  
8.                 ordertmp.OrderType = order.OrderType;  
9.                 ordertmp.APNumber = string.IsNullOrEmpty(order.APNumber) ? DBNull.Value : (object)order.APNumber;  
10.                 ordertmp.Memo = DBNull.Value;//备注  
11.                 Fast.Orm.ProcedureHelper.ProcedureOperation<prc_WLOrderTmpAdd>(ordertmp);  
12.                 return int.Parse(ordertmp.ErrID.ToString()) == 0 ? true : false;  

这样保证我们写的代码都围绕着数据实体来进行数据库的操作。

 

有了专业的代码生成器之后，一切就变的简单多了，我们按照自己的要求设计开发代码生成器来配合基础框架的使用，那么我们的开发效率将大大提高了。