开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > OA系统 > 查看源码
examineDAL.cs
资源名称：OASystem.rar　[点击查看]
上传用户：lishan0805
上传日期：2019-12-08
资源大小：12048k
文件大小：24k
源码类别：

OA系统

开发平台：

C#

examineDAL.cs：源码内容
  1. // =================================================================== 
  2. // 产品(COM.OA.SqlServerDAL)项目
  3. //====================================================================
  4. // wangyp @Copy Right 2006-2008
  5. // 文件：examineDAL.cs
  6. // 项目名称：工程项目管理
  7. // 创建时间：2008-9-23
  8. // 负责人：wangyp
  9. // 先创建SqlHelper.cs文件,引用System.Configuration程序集和实体(COM.OA.Entity)、产品规则(COM.OA.IDAL)项目、引用业务逻辑(COM.OA.BLL)项目
  10. // ===================================================================
  11. using System;
  12. using System.Collections;
  13. using System.Collections.Generic;
  14. using System.Data;
  15. using System.Data.SqlClient;
  16. using System.Text;
  17. using COM.OA.Entity;
  18. using COM.OA.IDAL;
  19. using COM.OA.BLL;
  21. namespace COM.OA.SqlServerDAL
  22. {
  23.     /// <summary>
  24.     /// 数据访问层dbo.examine
  25.     /// </summary>
  26.     public partial class examineDAL : IexamineDAL
  27.     {
  28.         #region 构造函数
  29.         /// <summary>
  30.         /// 数据层实例化
  31.         /// </summary>
  32.         public examineDAL()
  33.         {
  34.         }
  35.         #endregion
  37.         #region -----------实例化接口函数-----------
  39.         #region 添加
  40.         /// <summary>
  41.         /// 向数据库中插入一条新记录
  42.         /// </summary>
  43.         /// <param name="examine">examine实体对象</param>
  44.         /// <returns></returns>
  45.         public int Insert(examine examine)
  46.         {
  47.             string sqlCommand = "examineInsert";
  48.             int res;
  49.             SqlParameter[] param ={
  50. new SqlParameter("@ex_id",SqlDbType.Int),
  51. new SqlParameter("@ex_applycontent",SqlDbType.VarChar),
  52. new SqlParameter("@ex_define",SqlDbType.VarChar),
  53. new SqlParameter("@ex_remark",SqlDbType.VarChar),
  54. new SqlParameter("@ex_u_id",SqlDbType.Int),
  55. new SqlParameter("@ex_applytime",SqlDbType.DateTime),
  56. new SqlParameter("@ex_state",SqlDbType.Int),
  57. new SqlParameter("@ex_inceptid",SqlDbType.Int),
  58. new SqlParameter("@ex_examineidea",SqlDbType.VarChar),
  59. new SqlParameter("@ex_examinetiem",SqlDbType.DateTime),
  60. new SqlParameter("@ex_dept_id",SqlDbType.Int)
  61. };
  62.             param[0].Direction = ParameterDirection.Output;
  63.             param[1].Value = examine.ex_applycontent;
  64.             param[2].Value = examine.ex_define;
  65.             param[3].Value = examine.ex_remark;
  66.             param[4].Value = examine.ex_u_id;
  67.             param[5].Value = examine.ex_applytime;
  68.             param[6].Value = examine.ex_state;
  69.             param[7].Value = examine.ex_inceptid;
  70.             param[8].Value = examine.ex_examineidea;
  71.             param[9].Value = examine.ex_examinetiem;
  72.             param[10].Value = examine.ex_dept_id;
  73.             res = SqlHelper.ExecuteNonQuery(Conn.SqlConn, CommandType.StoredProcedure, sqlCommand, param);
  74.             examine.ex_id = ((param[0].Value) == DBNull.Value) ? 0 : Convert.ToInt32(param[0].Value);
  75.             return res;
  76.         }
  77.         /// <summary>
  78.         /// 向数据库中插入一条新记录。带事务
  79.         /// </summary>
  80.         /// <param name="sp">事务对象</param>
  81.         /// <param name="examine">examine实体对象</param>
  82.         /// <returns></returns>
  83.         public int Insert(SqlTransaction sp, examine examine)
  84.         {
  85.             string sqlCommand = "examineInsert";
  86.             int res;
  87.             SqlParameter[] param ={
  88. new SqlParameter("@ex_id",SqlDbType.Int),
  89. new SqlParameter("@ex_applycontent",SqlDbType.VarChar),
  90. new SqlParameter("@ex_define",SqlDbType.VarChar),
  91. new SqlParameter("@ex_remark",SqlDbType.VarChar),
  92. new SqlParameter("@ex_u_id",SqlDbType.Int),
  93. new SqlParameter("@ex_applytime",SqlDbType.DateTime),
  94. new SqlParameter("@ex_state",SqlDbType.Int),
  95. new SqlParameter("@ex_inceptid",SqlDbType.Int),
  96. new SqlParameter("@ex_examineidea",SqlDbType.VarChar),
  97. new SqlParameter("@ex_examinetiem",SqlDbType.DateTime),
  98. new SqlParameter("@ex_dept_id",SqlDbType.Int)
  99. };
  100.             param[0].Direction = ParameterDirection.Output;
  101.             param[1].Value = examine.ex_applycontent;
  102.             param[2].Value = examine.ex_define;
  103.             param[3].Value = examine.ex_remark;
  104.             param[4].Value = examine.ex_u_id;
  105.             param[5].Value = examine.ex_applytime;
  106.             param[6].Value = examine.ex_state;
  107.             param[7].Value = examine.ex_inceptid;
  108.             param[8].Value = examine.ex_examineidea;
  109.             param[9].Value = examine.ex_examinetiem;
  110.             param[10].Value = examine.ex_dept_id;
  111.             res = SqlHelper.ExecuteNonQuery(sp, CommandType.StoredProcedure, sqlCommand, param);
  112.             examine.ex_id = ((param[0].Value) == DBNull.Value) ? 0 : Convert.ToInt32(param[0].Value);
  113.             return res;
  114.         }
  115.         #endregion
  117.         #region 更新
  118.         /// <summary>
  119.         /// 向数据表examine更新一条记录
  120.         /// </summary>
  121.         /// <param name="examine">examine实体对象</param>
  122.         /// <returns></returns>
  123.         public int Update(examine examine)
  124.         {
  125.             string sqlCommand = "examineUpdate";
  126.             SqlParameter[] param ={
  127. new SqlParameter("@ex_id",SqlDbType.Int),
  128. new SqlParameter("@ex_applycontent",SqlDbType.VarChar),
  129. new SqlParameter("@ex_define",SqlDbType.VarChar),
  130. new SqlParameter("@ex_remark",SqlDbType.VarChar),
  131. new SqlParameter("@ex_u_id",SqlDbType.Int),
  132. new SqlParameter("@ex_applytime",SqlDbType.DateTime),
  133. new SqlParameter("@ex_state",SqlDbType.Int),
  134. new SqlParameter("@ex_inceptid",SqlDbType.Int),
  135. new SqlParameter("@ex_examineidea",SqlDbType.VarChar),
  136. new SqlParameter("@ex_examinetiem",SqlDbType.DateTime),
  137. new SqlParameter("@ex_dept_id",SqlDbType.Int)
  138. };
  139.             param[0].Value = examine.ex_id;
  140.             param[1].Value = examine.ex_applycontent;
  141.             param[2].Value = examine.ex_define;
  142.             param[3].Value = examine.ex_remark;
  143.             param[4].Value = examine.ex_u_id;
  144.             param[5].Value = examine.ex_applytime;
  145.             param[6].Value = examine.ex_state;
  146.             param[7].Value = examine.ex_inceptid;
  147.             param[8].Value = examine.ex_examineidea;
  148.             param[9].Value = examine.ex_examinetiem;
  149.             param[10].Value = examine.ex_dept_id;
  150.             return SqlHelper.ExecuteNonQuery(Conn.SqlConn, CommandType.StoredProcedure, sqlCommand, param);
  151.         }
  152.         /// <summary>
  153.         /// 向数据表examine更新一条记录。带事务
  154.         /// </summary>
  155.         /// <param name="sp">事务对象</param>
  156.         /// <param name="examine">examine实体对象</param>
  157.         /// <returns></returns>
  158.         public int Update(SqlTransaction sp, examine examine)
  159.         {
  160.             string sqlCommand = "examineUpdate";
  161.             SqlParameter[] param ={
  162. new SqlParameter("@ex_id",SqlDbType.Int),
  163. new SqlParameter("@ex_applycontent",SqlDbType.VarChar),
  164. new SqlParameter("@ex_define",SqlDbType.VarChar),
  165. new SqlParameter("@ex_remark",SqlDbType.VarChar),
  166. new SqlParameter("@ex_u_id",SqlDbType.Int),
  167. new SqlParameter("@ex_applytime",SqlDbType.DateTime),
  168. new SqlParameter("@ex_state",SqlDbType.Int),
  169. new SqlParameter("@ex_inceptid",SqlDbType.Int),
  170. new SqlParameter("@ex_examineidea",SqlDbType.VarChar),
  171. new SqlParameter("@ex_examinetiem",SqlDbType.DateTime),
  172. new SqlParameter("@ex_dept_id",SqlDbType.Int)
  173. };
  174.             param[0].Value = examine.ex_id;
  175.             param[1].Value = examine.ex_applycontent;
  176.             param[2].Value = examine.ex_define;
  177.             param[3].Value = examine.ex_remark;
  178.             param[4].Value = examine.ex_u_id;
  179.             param[5].Value = examine.ex_applytime;
  180.             param[6].Value = examine.ex_state;
  181.             param[7].Value = examine.ex_inceptid;
  182.             param[8].Value = examine.ex_examineidea;
  183.             param[9].Value = examine.ex_examinetiem;
  184.             param[10].Value = examine.ex_dept_id;
  185.             return SqlHelper.ExecuteNonQuery(sp, CommandType.StoredProcedure, sqlCommand, param);
  186.         }
  187.         #endregion
  189.         #region 删除
  190.         /// <summary>
  191.         /// 删除数据表examine中的一条记录
  192.         /// </summary>
  193.         /// <param name="ex_id">ex_id</param>
  194.         /// <returns></returns>
  195.         public int Delete(int ex_id)
  196.         {
  197.             string sqlCommand = "examineDelete";
  198.             SqlParameter[] param ={
  199. new SqlParameter("@ex_id",SqlDbType.Int)
  200. };
  201.             param[0].Value = ex_id;
  202.             return SqlHelper.ExecuteNonQuery(Conn.SqlConn, CommandType.StoredProcedure, sqlCommand, param);
  203.         }
  204.         /// <summary>
  205.         /// 删除数据表examine中的一条记录
  206.         /// </summary>
  207.         /// <param name="examine">examine实体对象</param>
  208.         /// <returns></returns>
  209.         public int Delete(examine examine)
  210.         {
  211.             string sqlCommand = "examineDelete";
  212.             SqlParameter[] param ={
  213. new SqlParameter("@ex_id",SqlDbType.Int)
  214. };
  215.             param[0].Value = examine.ex_id;
  216.             return SqlHelper.ExecuteNonQuery(Conn.SqlConn, CommandType.StoredProcedure, sqlCommand, param);
  217.         }
  218.         /// <summary>
  219.         /// 删除数据表examine中的一条记录,带事务
  220.         /// </summary>
  221.         /// <param name="sp">事务对象</param>
  222.         /// <param name="ex_id">ex_id</param>
  223.         /// <returns></returns>
  224.         public int Delete(SqlTransaction sp, int ex_id)
  225.         {
  226.             string sqlCommand = "examineDelete";
  227.             SqlParameter[] param ={
  228. new SqlParameter("@ex_id",SqlDbType.Int)
  229. };
  230.             param[0].Value = ex_id;
  231.             return SqlHelper.ExecuteNonQuery(sp, CommandType.StoredProcedure, sqlCommand, param);
  232.         }
  234.         /// <summary>
  235.         /// 删除数据表examine中的一条记录,带事务
  236.         /// </summary>
  237.         /// <param name="sp">事务对象</param>
  238.         /// <param name="examine">examine实体对象</param>
  239.         /// <returns></returns>
  240.         public int Delete(SqlTransaction sp, examine examine)
  241.         {
  242.             string sqlCommand = "examineDelete";
  243.             SqlParameter[] param ={
  244. new SqlParameter("@ex_id",SqlDbType.Int)
  245. };
  246.             param[0].Value = examine.ex_id;
  247.             return SqlHelper.ExecuteNonQuery(sp, CommandType.StoredProcedure, sqlCommand, param);
  248.         }
  249.         #endregion
  251.         #region 实体对象
  252.         /// <summary>
  253.         /// 得到examine实体对象
  254.         /// </summary>
  255.         /// <param name="row">row</param>
  256.         /// <returns>examine实体对象</returns>
  257.         public examine Select(DataRow row)
  258.         {
  259.             examine obj = new examine();
  260.             if (row != null)
  261.             {
  262.                 obj.ex_id = ((row["ex_id"]) == DBNull.Value) ? 0 : Convert.ToInt32(row["ex_id"]);
  263.                 obj.ex_applycontent = row["ex_applycontent"].ToString();
  264.                 obj.ex_define = row["ex_define"].ToString();
  265.                 obj.ex_remark = row["ex_remark"].ToString();
  266.                 obj.ex_u_id = ((row["ex_u_id"]) == DBNull.Value) ? 0 : Convert.ToInt32(row["ex_u_id"]);
  267.                 obj.ex_applytime = ((row["ex_applytime"]) == DBNull.Value) ? DateTime.MinValue : Convert.ToDateTime(row["ex_applytime"]);
  268.                 obj.ex_state = ((row["ex_state"]) == DBNull.Value) ? 0 : Convert.ToInt32(row["ex_state"]);
  269.                 obj.ex_inceptid = ((row["ex_inceptid"]) == DBNull.Value) ? 0 : Convert.ToInt32(row["ex_inceptid"]);
  270.                 obj.ex_examineidea = row["ex_examineidea"].ToString();
  271.                 obj.ex_examinetiem = ((row["ex_examinetiem"]) == DBNull.Value) ? DateTime.MinValue : Convert.ToDateTime(row["ex_examinetiem"]);
  272.                 obj.ex_dept_id = ((row["ex_dept_id"]) == DBNull.Value) ? 0 : Convert.ToInt32(row["ex_dept_id"]);
  273.             }
  274.             else
  275.             {
  276.                 return null;
  277.             }
  278.             return obj;
  279.         }
  281.         /// <summary>
  282.         /// 得到examine实体对象
  283.         /// </summary>
  284.         /// <param name="dr">dr</param>
  285.         /// <returns>examine实体对象</returns>
  286.         public examine Select(IDataReader dr)
  287.         {
  288.             examine obj = new examine();
  289.             obj.ex_id = ((dr["ex_id"]) == DBNull.Value) ? 0 : Convert.ToInt32(dr["ex_id"]);
  290.             obj.ex_applycontent = dr["ex_applycontent"].ToString();
  291.             obj.ex_define = dr["ex_define"].ToString();
  292.             obj.ex_remark = dr["ex_remark"].ToString();
  293.             obj.ex_u_id = ((dr["ex_u_id"]) == DBNull.Value) ? 0 : Convert.ToInt32(dr["ex_u_id"]);
  294.             obj.ex_applytime = ((dr["ex_applytime"]) == DBNull.Value) ? DateTime.MinValue : Convert.ToDateTime(dr["ex_applytime"]);
  295.             obj.ex_state = ((dr["ex_state"]) == DBNull.Value) ? 0 : Convert.ToInt32(dr["ex_state"]);
  296.             obj.ex_inceptid = ((dr["ex_inceptid"]) == DBNull.Value) ? 0 : Convert.ToInt32(dr["ex_inceptid"]);
  297.             obj.ex_examineidea = dr["ex_examineidea"].ToString();
  298.             obj.ex_examinetiem = ((dr["ex_examinetiem"]) == DBNull.Value) ? DateTime.MinValue : Convert.ToDateTime(dr["ex_examinetiem"]);
  299.             obj.ex_dept_id = ((dr["ex_dept_id"]) == DBNull.Value) ? 0 : Convert.ToInt32(dr["ex_dept_id"]);
  300.             return obj;
  301.         }
  303.         /// <summary>
  304.         /// 根据ID,返回一个examine实体对象
  305.         /// </summary>
  306.         /// <param name="ex_id">ex_id</param>
  307.         /// <returns>examine实体对象</returns>
  308.         public examine Select(int ex_id)
  309.         {
  310.             return this.Select(ex_id, false, false);
  311.         }
  312.         /// <summary>
  313.         /// 根据ID,返回一个examine实体对象
  314.         /// </summary>
  315.         /// <param name="ex_id">ex_id</param>
  316.         /// <param name="bParentTable">将examine对象设置与父表关联</param>
  317.         /// <param name="bChildrenTable">将examine对象设置与子表关联</param>
  318.         /// <returns>examine实体对象</returns>
  319.         public examine Select(int ex_id, bool bParentTable, bool bChildrenTable)
  320.         {
  321.             examine obj = null;
  322.             SqlParameter[] param ={
  323. new SqlParameter("@ex_id",SqlDbType.Int)
  324. };
  325.             param[0].Value = ex_id;
  326.             string sqlCommand = "examineSelect";
  327.             using (SqlDataReader dr = SqlHelper.ExecuteReader(Conn.SqlConn, CommandType.StoredProcedure, sqlCommand, param))
  328.             {
  329.                 while (dr.Read())
  330.                 {
  331.                     obj = this.Select(dr);
  332.                 }
  333.             }
  334.             this.Select(obj, bParentTable, bChildrenTable);
  335.             return obj;
  336.         }
  337.         /// <summary>
  338.         /// 将examine实体对象设置与父表和子表关联
  339.         /// </summary>
  340.         /// <param name="obj">examine实体对象</param>
  341.         /// <param name="bParentTable">是/否设置与父表对象关联</param>
  342.         /// <param name="bChildrenTable">是/否设置与子表对象关联</param>
  343.         public void Select(examine obj, bool bParentTable, bool bChildrenTable)
  344.         {
  345.             //关联的主表
  346.             if (bParentTable)
  347.             {
  348.                 obj.users = usersBLL.Select(obj.ex_u_id);
  349.                 obj.department = departmentBLL.Select(obj.ex_dept_id);
  350.             }
  351.             //关联的子表集合
  352.             if (bChildrenTable)
  353.             {
  354.             }
  355.         }
  356.         #endregion
  358.         #region 父表
  359.         /// <summary>
  360.         /// 设置实体对象(examine)的父表对象
  361.         /// </summary>
  362.         /// <param name="examine">实体对象</param>
  363.         public void users(examine examine)
  364.         {
  365.             examine.users = usersBLL.Select(examine.ex_u_id);
  366.         }
  367.         /// <summary>
  368.         /// 设置实体对象(examine)的父表对象
  369.         /// </summary>
  370.         /// <param name="examine">实体对象</param>
  371.         public void department(examine examine)
  372.         {
  373.             examine.department = departmentBLL.Select(examine.ex_dept_id);
  374.         }
  375.         #endregion
  377.         #region 子表
  378.         #endregion
  380.         #region 查询
  381.         /// <summary>
  382.         /// 得到数据表examine所有记录
  383.         /// </summary>
  384.         /// <returns>结果集</returns>
  385.         public IList<examine> Select()
  386.         {
  387.             return this.Select(false, false);
  388.         }
  389.         /// <summary>
  390.         /// 得到数据表examine所有记录
  391.         /// </summary>
  392.         /// <param name="bParentTable">是/否设置与父表对象关联</param>
  393.         /// <param name="bChildrenTable">是/否设置与子表对象关联</param>
  394.         /// <returns>结果集</returns>
  395.         public IList<examine> Select(bool bParentTable, bool bChildrenTable)
  396.         {
  397.             IList<examine> list = new List<examine>();
  398.             string sqlCommand = "examineSelectAll";
  399.             using (SqlDataReader dr = SqlHelper.ExecuteReader(Conn.SqlConn, CommandType.StoredProcedure, sqlCommand))
  400.             {
  401.                 while (dr.Read())
  402.                 {
  403.                     list.Add(this.Select(dr));
  404.                 }
  405.             }
  406.             foreach (examine obj in list)
  407.             {
  408.                 this.Select(obj, bParentTable, bChildrenTable);
  409.             }
  410.             return list;
  411.         }
  412.         /// <summary>
  413.         /// 得到数据表examine满足查询条件的记录
  414.         /// </summary>
  415.         /// <param name="where">查询条件</param>
  416.         /// <returns>结果集</returns>
  417.         public IList<examine> Select(string where)
  418.         {
  419.             return this.Select(where, false, false);
  420.         }
  421.         /// <summary>
  422.         /// 得到数据表examine满足查询条件的记录
  423.         /// </summary>
  424.         /// <param name="where">查询条件</param>
  425.         /// <param name="bParentTable">是/否设置与父表对象关联</param>
  426.         /// <param name="bChildrenTable">是/否设置与子表对象关联</param>
  427.         /// <returns>结果集</returns>
  428.         public IList<examine> Select(string where, bool bParentTable, bool bChildrenTable)
  429.         {
  430.             IList<examine> list = new List<examine>();
  431.             SqlParameter[] param ={
  432. new SqlParameter("@where",SqlDbType.VarChar,8000)
  433. };
  434.             param[0].Value = where;
  435.             string sqlCommand = "examineSelectByParams";
  436.             using (SqlDataReader dr = SqlHelper.ExecuteReader(Conn.SqlConn, CommandType.StoredProcedure, sqlCommand, param))
  437.             {
  438.                 while (dr.Read())
  439.                 {
  440.                     list.Add(this.Select(dr));
  441.                 }
  442.             }
  443.             foreach (examine obj in list)
  444.             {
  445.                 this.Select(obj, bParentTable, bChildrenTable);
  446.             }
  447.             return list;
  448.         }
  449.         /// <summary>
  450.         /// 得到数据表ArticalInfo满足外键字段查询条件的记录
  451.         /// </summary>
  452.         /// <param name="foreignFieldName">外键字段名称</param>
  453.         /// <param name="foreignFieldValue">外键字段值</param>
  454.         /// <returns>结果集</returns>
  455.         public IList<examine> Select(string foreignFieldName, int foreignFieldValue)
  456.         {
  457.             return this.Select(foreignFieldName, foreignFieldValue, false, false);
  458.         }
  459.         /// <summary>
  460.         /// 得到数据表ArticalInfo满足外键字段查询条件的记录
  461.         /// </summary>
  462.         /// <param name="foreignFieldName">外键字段名称</param>
  463.         /// <param name="foreignFieldValue">外键字段值</param>
  464.         /// <param name="bParentTable">是/否设置与父表对象关联</param>
  465.         /// <param name="bChildrenTable">是/否设置与子表对象关联</param>
  466.         /// <returns>结果集</returns>
  467.         public IList<examine> Select(string foreignFieldName, int foreignFieldValue, bool bParentTable, bool bChildrenTable)
  468.         {
  469.             return this.Select(string.Format("{0}='{1}'", foreignFieldName, foreignFieldValue), bParentTable, bChildrenTable);
  470.         }
  471.         /// <summary>
  472.         /// 得到数据表examine满足查询条件的记录数
  473.         /// </summary>
  474.         /// <param name="where">查询条件</param>
  475.         /// <param name="recordCount">记录数</param>
  476.         public void Select(string where, out int recordCount)
  477.         {
  478.             string sqlCommand = "examineCountByWhere";
  479.             SqlParameter[] param ={
  480. new SqlParameter("@where",SqlDbType.VarChar,8000),
  481. new SqlParameter("@recordCount",SqlDbType.Int)
  482. };
  483.             param[0].Value = where;
  484.             param[1].Direction = ParameterDirection.Output;
  485.             SqlHelper.ExecuteNonQuery(Conn.SqlConn, CommandType.StoredProcedure, sqlCommand, param);
  486.             recordCount = Convert.ToInt32(param[1].Value);
  487.         }
  488.         /// <summary>
  489.         /// 得到数据表examine满足查询条件的分页记录
  490.         /// </summary>
  491.         /// <param name="pageSize">每页显示记录数</param>
  492.         /// <param name="pageIndex">当前显示第几页</param>
  493.         /// <param name="where">查询条件</param>
  494.         /// <returns>结果集</returns>
  495.         public IList<examine> Select(int pageSize, int pageIndex, string where)
  496.         {
  497.             return this.Select(pageSize, pageIndex, where, false, false);
  498.         }
  499.         /// <summary>
  500.         /// 得到数据表examine满足查询条件的分页记录
  501.         /// </summary>
  502.         /// <param name="pageSize">每页显示记录数</param>
  503.         /// <param name="pageIndex">当前显示第几页</param>
  504.         /// <param name="where">查询条件</param>
  505.         /// <param name="bParentTable">是/否设置与父表对象关联</param>
  506.         /// <param name="bChildrenTable">是/否设置与子表对象关联</param>
  507.         /// <returns>结果集</returns>
  508.         public IList<examine> Select(int pageSize, int pageIndex, string where, bool bParentTable, bool bChildrenTable)
  509.         {
  510.             IList<examine> list = new List<examine>();
  511.             string sqlCommand = "examineSelectByPagerParams";
  512.             SqlParameter[] param ={
  513. new SqlParameter("@pageSize",SqlDbType.Int),
  514. new SqlParameter("@pageIndex",SqlDbType.Int),
  515. new SqlParameter("@where",SqlDbType.VarChar,8000)
  516. };
  517.             param[0].Value = pageSize;
  518.             param[1].Value = pageIndex;
  519.             param[2].Value = where;
  520.             using (SqlDataReader dr = SqlHelper.ExecuteReader(Conn.SqlConn, CommandType.StoredProcedure, sqlCommand, param))
  521.             {
  522.                 while (dr.Read())
  523.                 {
  524.                     list.Add(this.Select(dr));
  525.                 }
  526.             }
  527.             foreach (examine obj in list)
  528.             {
  529.                 this.Select(obj, bParentTable, bChildrenTable);
  530.             }
  531.             return list;
  532.         }
  533.         /// <summary>
  534.         /// 得到数据表examine满足查询条件记录
  535.         /// </summary>
  536.         /// <param name="commandType">命令类型</param>
  537.         /// <param name="sqlCommand">SQL命令</param>
  538.         /// <param name="SqlParameter[]">命令参数数组</param>
  539.         /// <returns>结果集</returns>
  540.         public IList<examine> Select(CommandType commandType, string sqlCommand, params SqlParameter[] param)
  541.         {
  542.             return this.Select(false, false, commandType, sqlCommand, param);
  543.         }
  544.         /// <summary>
  545.         /// 得到数据表examine满足查询条件记录
  546.         /// </summary>
  547.         /// <param name="bParentTable">是/否设置与父表对象关联</param>
  548.         /// <param name="bChildrenTable">是/否设置与子表对象关联</param>
  549.         /// <param name="commandType">命令类型</param>
  550.         /// <param name="sqlCommand">SQL命令</param>
  551.         /// <param name="SqlParameter[]">命令参数数组</param>
  552.         /// <returns>结果集</returns>
  553.         public IList<examine> Select(bool bParentTable, bool bChildrenTable, CommandType commandType, string sqlCommand, params SqlParameter[] param)
  554.         {
  555.             IList<examine> list = new List<examine>();
  556.             using (SqlDataReader dr = SqlHelper.ExecuteReader(Conn.SqlConn, commandType, sqlCommand, param))
  557.             {
  558.                 while (dr.Read())
  559.                 {
  560.                     list.Add(this.Select(dr));
  561.                 }
  562.             }
  563.             foreach (examine obj in list)
  564.             {
  565.                 this.Select(obj, bParentTable, bChildrenTable);
  566.             }
  567.             return list;
  568.         }
  569.         /// <summary>
  570.         /// 根据主键检测是否存在该条记录
  571.         /// </summary>
  572.         /// <param name="ex_id">ex_id</param>
  573.         /// <returns>存在/不存在</returns>
  574.         public bool Exists(int ex_id)
  575.         {
  576.             SqlParameter[] param ={
  577.                                  new SqlParameter("@ex_id",SqlDbType.Int)
  578.                                  };
  579.             param[0].Value = ex_id;
  580.             string sqlCommand = "examineIsExist";
  581.             int a = Convert.ToInt32(SqlHelper.ExecuteScalar(Conn.SqlConn, CommandType.StoredProcedure, sqlCommand, param));
  582.             if (a > 0)
  583.             {
  584.                 return true;
  585.             }
  586.             else
  587.             {
  588.                 return false;
  589.             }
  590.         }
  591.         #endregion
  593.         #endregion
  594.     }
  595. }