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

经过与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[]对象，如果你的创建始终是使用反射的话那么将是不可取的。有兴趣的朋友可以参见本人的另一篇文章“利用抽象、多态实现无反射的绿色环保ORM框架”对实体的使用如果不能摆脱反射，那么在以后的基础库扩展中将面临着很多性能问题，这里需三思。

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

在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;

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

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