数据库操作类(SQL版)

前几天写的.专门针对SQL的.分页需要结合一个存储过程来用.
下面是代码:

  1"导入的命名空间"#region "导入的命名空间"
  2using System;
  3using System.Data;
  4using System.Data.SqlClient;
  5using System.Web;
  6using System.Web.SessionState;
  7using System.Web.UI;
  8using System.Text;
  9using System.Collections.Generic;
 10#endregion
 11
 12" databases 数据操作层"#region " databases 数据操作层"
 13
 14/**////新建的数据操作层
 15[assembly: CLSCompliant(true)]
 16namespace databases
 17{
 18
 19    " database 数据库基本操作类 "#region " database 数据库基本操作类 "
 20    /**//// <summary>
 21    /// 数据库操作类
 22    /// </summary>
 23    public class database : IDisposable
 24    {
 25
 26        " link_str 连接数据库字符串属性 "#region " link_str 连接数据库字符串属性 "
 27        /**//// <summary>
 28        /// 增加一个连接数据库字符的属性
 29        /// </summary>
 30        private string link_str = System.Configuration.ConfigurationManager.AppSettings["link_mdbs"].ToString();
 31        public string Link_str
 32        {
 33            get
 34            {
 35                return link_str;
 36            }
 37
 38            set
 39            {
 40               link_str = value;
 41            }
 42        }
 43        #endregion
 44
 45        " 其它属性 "#region " 其它属性 "
 46        private int allpage = 0;      /**////分页函数中记录共有多少页的变量
 47        public int Allpage
 48        {
 49            get
 50            {
 51                return allpage;
 52            }
 53        }
 54
 55        private int allrecord = 0;    /**////分页函数中记录菜有数据总量的变量
 56        public int Allrecord
 57        {
 58            get
 59            {
 60                return allrecord;
 61            }
 62        }
 63
 64        /**//// <summary>
 65        /// 属性SqlConnection
 66        /// </summary>
 67        private SqlConnection conn;
 68        public SqlConnection Conn
 69        {
 70            get
 71            {
 72                return conn;
 73            }
 74            set
 75            {
 76                conn = value;
 77            }
 78        }
 79        
 80        /**//// <summary>
 81        /// 属性SqlDataAdapter
 82        /// </summary>
 83        private SqlDataAdapter adp;
 84        public SqlDataAdapter Adp
 85        {
 86            get
 87            {
 88                return adp;
 89            }
 90            set
 91            {
 92                adp = value;
 93            }
 94        }
 95        
 96        /**//// <summary>
 97        /// 属性SqlCommand
 98        /// </summary>
 99        private SqlCommand cmd;
100        public SqlCommand Cmd
101        {
102            get
103            {
104                return cmd;
105            }
106            set
107            {
108                cmd = value;
109            }
110        }
111
112        private SqlTransaction Tran;
113        #endregion
114
115        " 数据库基本操作 "#region " 数据库基本操作 "
116
117        /**//// <summary>
118        /// 打开数据库
119        /// </summary>
120        public void opencon()
121        {
122            conn = new SqlConnection();
123            conn.ConnectionString = link_str;
124            /**//*if (conn.State != ConnectionState.Open)   ///不重复打开数据库连接  暂时不打开
125                conn.Open();*/
126        }
127
128        /**//// <summary>
129        /// 关闭数据库连接
130        /// </summary>
131        public void CloseCon()
132        {
133            if (conn != null && conn.State == ConnectionState.Open)
134            {
135                conn.Close();
136            }
137
138            if (cmd != null)
139            {
140                cmd.Dispose();
141                cmd = null;
142            }
143
144            if (adp != null)
145            {
146                adp.Dispose();
147                adp = null;
148            }
149
150            if (Tran != null)
151            {
152                Tran.Dispose();
153                Tran = null;
154            }
155
156            if (conn != null)
157            {
158                conn.Dispose();
159                conn = null;
160            }
161            GC.Collect();       /**////强制对所有代进行垃圾回收
162        }
163
164        /**//// <summary>
165        /// 创建SQLCOMMAND对像
166        /// </summary>
167        /// <param name="sql">SQL语句</param>
168        /// <returns></returns>
169        private SqlCommand Create_cmd_text(string sql)
170        {
171            opencon();
172            cmd = new SqlCommand();  //传送SQL语句
173            cmd.Connection = conn;
174            cmd.CommandText = sql;
175            return cmd;
176        }
177
178        /**//// <summary>
179        /// 创建执行存储过程的CMD对像
180        /// </summary>
181        /// <param name="procname">存储过程名</param>
182        /// <param name="parames">存储过程参数</param>
183        /// <returns></returns>
184        private SqlCommand Create_cmd_pro(string procname,SqlParameter[] parames)
185        {
186            opencon();
187            cmd = new SqlCommand(procname,conn);  //传送存储过程
188            cmd.CommandType = CommandType.StoredProcedure;
189
190            // 依次把参数传入存储过程 
191            if (parames != null)
192            {
193                foreach (SqlParameter parameter in parames)
194                    cmd.Parameters.Add(parameter);
195            }
196
197            // 加入返回参数 
198            cmd.Parameters.Add(
199                new SqlParameter("ReturnValue", SqlDbType.Int, 4,
200                ParameterDirection.ReturnValue, false, 0, 0,
201                string.Empty, DataRowVersion.Default, null)); 
202
203            return cmd;
204        }
205
206        /**//// <summary>
207        /// 创建一个事务
208        /// </summary>
209        public void BeginTran()
210        {
211            if (Tran == null)   /**////如果事务不存在，则创建
212            {
213                Tran = conn.BeginTransaction();
214            }
215        }
216
217        /**//// <summary>
218        /// 回滚一个事务
219        /// </summary>
220        public void RollbackTran()
221        {
222            if (Tran != null)
223            {
224                Tran.Rollback();   /**////回滚事务
225                Tran = null;
226            }
227        }
228
229        /**//// <summary>
230        /// 完成事务
231        /// </summary>
232        public void CommitTran()
233        {
234            if (Tran != null)
235            {
236                Tran.Commit();
237                Tran = null;
238            }
239        }
240
241        #endregion
242
243        " 操作SQL语句函数 "#region " 操作SQL语句函数 "
244
245        " getdr 返回SqlDataReader对像 "#region " getdr 返回SqlDataReader对像 "
246        /**//// <summary>
247        /// 取是SqlDataReader对像
248        /// </summary>
249        /// <param name="sql">SQL语句</param>
250        /// <param name="parames">需要传递的参数</param>
251        /// <returns>dataReader</returns>
252        public SqlDataReader getdr(string sql,SqlParameter[] parames)
253        {
254            SqlCommand cmds = Create_cmd_text(sql);   //建立COMMAND对像
255
256            // 依次把参数传入
257            if (parames != null)
258            {
259                foreach (SqlParameter parameter in parames)
260                    cmds.Parameters.Add(parameter);
261            }
262
263            SqlDataReader dataReader = null;
264
265            try
266            {
267                if (conn.State != ConnectionState.Open)   /**////不重复打开数据库连接
268                {
269                    conn.Open();
270                }
271                
272                dataReader = cmds.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
273
274            }
275            catch (Exception ex)
276            {
277                throw new Exception("出现异常" + ex.ToString());
278            }
279            finally
280            {
281                if (parames != null)
282                {
283                    cmds.Parameters.Clear();  /**////清空参数
284                }
285                cmds.Dispose();           /**////清空参数及释放CMD的
286            }
287
288            return dataReader;
289        }
290        #endregion
291
292        " getdt 返回DataTable对像 "#region " getdt 返回DataTable对像 "
293        /**//// <summary>
294        /// 返回DataTable
295        /// </summary>
296        /// <param name="sql">SQL语句</param>
297        /// <param name="parames">各个参数</param>
298        /// <returns>dt</returns>
299        public DataTable getdt(string sql, SqlParameter[] parames)
300        {
301            SqlCommand cmds = Create_cmd_text(sql);   //建立COMMAND对像
302            // 依次把参数传入
303            if (parames != null)
304            {
305                foreach (SqlParameter parameter in parames)
306                    cmds.Parameters.Add(parameter);
307            }
308            DataTable dt = new DataTable();
309
310            try
311            {
312                if (conn.State != ConnectionState.Open)   /**////不重复打开数据库连接
313                {
314                    conn.Open();
315                }
316
317                SqlDataReader dataReader = cmds.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
318
319                if (dataReader.HasRows)
320                {
321                   dt.Load(dataReader);
322                   dataReader.Close();            /**////先关闭再释放
323                   dataReader.Dispose();
324                }
325            }
326            catch (Exception ex)
327            {
328                throw new Exception("出现异常" + ex.ToString());
329            }
330            finally
331            {
332                if (parames != null)
333                {
334                    cmds.Parameters.Clear();  /**////清空参数
335                }
336                CloseCon();               /**////释放连接数据库各项
337            }
338
339            return dt;                    /**////返回虚拟表
340        }
341        #endregion
342
343        " get_sca 泛型函数，返回executescalar() "#region " get_sca 泛型函数，返回executescalar() "
344        /**//// <summary>
345        /// 泛型函数，返回executescalar()
346        /// </summary>
347        /// <typeparam name="T">泛型未定义的类型</typeparam>
348        /// <param name="sql">SQL语句</param>
349        /// <param name="parames">参数</param>
350        /// <returns>t_str</returns>
351        public T get_sca<T>(string sql, SqlParameter[] parames)
352        {
353            SqlCommand cmds = Create_cmd_text(sql);   //建立COMMAND对像
354            // 依次把参数传入
355            if (parames != null)
356            {
357                foreach (SqlParameter parameter in parames)
358                    cmds.Parameters.Add(parameter);
359            }
360
361            T t_str;   /**////泛型变量
362
363            try
364            {
365                if (conn.State != ConnectionState.Open)   /**////不重复打开数据库连接
366                {
367                    conn.Open();
368                }
369
370                    t_str = (T)cmd.ExecuteScalar();           /**////读取第一行第一列
371            }
372            catch
373            {
374                return default(T);
375            }
376            finally
377            {
378                if (parames != null)
379                {
380                    cmds.Parameters.Clear();  /**////清空参数
381                }
382                CloseCon();               /**////释放连接数据库各项
383            }
384
385            return t_str;
386        }
387        #endregion
388
389        " getds 返回dataset 重载1 "#region " getds 返回dataset 重载1 "
390        /**//// <summary>
391        /// 返回DATASET ,函数重载版本1
392        /// </summary>
393        /// <param name="sql"> SQL语句 </param>
394        /// <returns></returns>
395        public DataSet getds(string sql)
396        {
397            opencon();
398            adp = new SqlDataAdapter(sql, conn);
399            DataSet ds = new DataSet();
400            try
401            {
402                adp.Fill(ds);
403            }
404            catch (Exception ex)
405            {
406                throw new Exception("出现异常" + ex.ToString());
407            }
408            finally
409            {
410                CloseCon();               /**////释放连接数据库各项
411            }
412            return ds;
413        }
414        #endregion
415
416        " 返回ds 重载版本2 明确表名 "#region " 返回ds 重载版本2 明确表名 "
417        /**//// <summary>
418        /// 返回Ds，函数重载版本2
419        /// </summary>
420        /// <param name="tablename">要填充的表名</param>
421        /// <param name="sql">sql 语句</param>
422        /// <returns></returns>
423        public DataSet getds(string tablename, string sql)
424        {
425            opencon();
426            adp = new SqlDataAdapter(sql, conn);
427            DataSet ds = new DataSet();
428            try
429            {
430                adp.Fill(ds,tablename);
431            }
432            catch (Exception ex)
433            {
434                throw new Exception("出现异常" + ex.ToString());
435            }
436            finally
437            {
438                CloseCon();               /**////释放连接数据库各项
439            }
440            return ds;
441        }
442        #endregion
443
444        " runsql 运行SQL语句 "#region " runsql 运行SQL语句 "
445        /**//// <summary>
446        /// 直接运行SQL语句
447        /// </summary>
448        /// <param name="sql">SQL语句</param>
449        /// <param name="parames">参数数组</param>
450        /// <returns></returns>
451        public int runsql(string sql, SqlParameter[] parames)
452        {
453            SqlCommand cmds = Create_cmd_text(sql);   //建立COMMAND对像
454            // 依次把参数传入
455            if (parames != null)
456            {
457                foreach (SqlParameter parameter in parames)
458                    cmds.Parameters.Add(parameter);
459            }
460
461            int return_int;
462
463            try
464            {
465                if (conn.State != ConnectionState.Open)   /**////不重复打开数据库连接
466                {
467                    conn.Open();
468                }
469                BeginTran();     /**////开始一个事务处理   函数有可能会运行多条SQL语句
470                cmds.Transaction = Tran;
471                           
472                return_int = cmds.ExecuteNonQuery();
473                CommitTran();    /**////完成一个事务
474            }
475            catch (Exception ex)
476            {
477                RollbackTran();  /**////回滚事务
478                throw new Exception("出现异常" + ex.ToString());
479            }
480            finally
481            {
482                if (parames != null)
483                {
484                    cmds.Parameters.Clear();  /**////清空参数
485                }
486                CloseCon();               /**////释放连接数据库各项
487            }
488            return return_int;
489        }
490        #endregion
491
492        #endregion
493
494        " 操作存储过程的函数 "#region " 操作存储过程的函数 "
495
496        " 泛型函数，读取第一行第一列 "#region " 泛型函数，读取第一行第一列 "
497        /**//// <summary>
498        /// 泛型函数 读取第一行第一列
499        /// </summary>
500        /// <typeparam name="T">泛型替代符</typeparam>
501        /// <param name="proc_name">存储过程</param>
502        /// <param name="parames">参数名</param>
503        /// <returns></returns>
504        public T RunPro_sca<T>(string proc_name, SqlParameter[] parames)
505        {
506            SqlCommand cmds = Create_cmd_pro(proc_name, parames);
507
508            T t_str;   /**////泛型变量
509
510            try
511            {
512                if (conn.State != ConnectionState.Open)   /**////不重复打开数据库连接
513                {
514                    conn.Open();
515                }
516
517                t_str = (T)cmd.ExecuteScalar();           /**////读取第一行第一列
518
519            }
520            catch
521            {
522                return default(T);     //出错就返回默认
523            }
524            finally
525            {
526                if (parames != null)
527                {
528                    cmds.Parameters.Clear();  /**////清空参数
529                }
530                CloseCon();               /**////释放连接数据库各项
531            }
532
533            return t_str;
534        }
535        #endregion
536
537        " getds 获得DataSet对像 "#region " getds 获得DataSet对像 "
538        /**//// <summary>
539        /// 取得DataSet对像,重载版本2
540        /// </summary>
541        /// <param name="proc_name">存储过程名</param>
542        /// <param name="parames">存储过程参数</param>
543        /// <returns></returns>
544        public DataSet getds(string proc_name, SqlParameter[] parames)
545        {
546            SqlCommand cmds = Create_cmd_pro(proc_name, parames);
547            adp = new SqlDataAdapter(cmds);
548            DataSet ds = new DataSet();
549            try
550            {
551                adp.Fill(ds);
552            }
553            catch (Exception ex)
554            {
555                throw new Exception("出现异常" + ex.ToString());
556            }
557            finally
558            {
559                CloseCon();               /**////释放连接数据库各项
560            }
561
562            return ds;
563        }
564        #endregion
565
566        " RunPro 运行存储过程，有事务 "#region " RunPro 运行存储过程，有事务 "
567        /**//// <summary>
568        /// 执行存储过程,返回运行结果
569        /// </summary>
570        /// <param name="proc_name">存储过程名</param>
571        /// <param name="parames">传递来的参数</param>
572        /// <returns></returns>
573        public int RunPro(string proc_name,SqlParameter[] parames)
574        {
575            SqlCommand cmds = Create_cmd_pro(proc_name, parames);
576            int return_int;
577
578            try
579            {
580                if (conn.State != ConnectionState.Open)   /**////不重复打开数据库连接
581                {
582                    conn.Open();
583                }
584
585                BeginTran();     /**////开始一个事务处理
586                                 ///
587                cmds.Transaction = Tran;
588
589                return_int = cmds.ExecuteNonQuery();
590
591                CommitTran();    /**////完成一个事务
592            }
593            catch (Exception ex)
594            {
595                RollbackTran();  /**////回滚事务
596
597                throw new Exception("出现异常" + ex.ToString());
598            }
599            finally
600            {
601                if (parames != null)
602                    cmds.Parameters.Clear();  /**////如果存在参数，那么就清空参数
603                                          
604                CloseCon();                   /**////释放连接数据库各项
605            }
606
607            return return_int;
608
609        }
610        #endregion
611
612        " RunPro_getid 获取插入数据后的自增ID "#region " RunPro_getid 获取插入数据后的自增ID "
613        /**//// <summary>
614        /// 执行存储过程  只返回主键ID [ identity ]
615        /// </summary>
616        /// <param name="proc_name">存储过程名</param>
617        /// <param name="parames">存储过程参数</param>
618        /// <returns></returns>
619        public int RunPro_getid(string proc_Name, SqlParameter[] parames)
620        {
621            SqlCommand cmds = Create_cmd_pro(proc_Name, parames);
622            int return_int;
623
624            try
625            {
626                if (conn.State != ConnectionState.Open)   /**////不重复打开数据库连接
627                {
628                    conn.Open();
629                }
630
631                BeginTran();     /**////开始一个事务处理
632                                 ///
633                cmds.Transaction = Tran;
634
635                cmds.ExecuteNonQuery();
636
637                CommitTran();    /**////完成一个事务
638
639                return_int = (int)cmd.Parameters["ReturnValue"].Value;
640
641            }
642            catch (Exception ex)
643            {
644                RollbackTran();  /**////回滚事务
645                throw new Exception("出现异常" + ex.ToString());
646            }
647            finally
648            {
649                if (parames != null)
650                    cmds.Parameters.Clear();  /**////如果存在参数，那么就清空参数
651
652                CloseCon();                   /**////释放连接数据库各项
653            }
654
655            return return_int;
656        }
657        #endregion
658
659        " RunPro_getdr 获取SqlDataReader对像 "#region " RunPro_getdr 获取SqlDataReader对像 "
660        /**//// <summary>
661        /// 返回SqlDataReader 
662        /// </summary>
663        /// <param name="proc_name">存储过程名</param>
664        /// <param name="parames">存储过程参数</param>
665        /// <returns>dr</returns>
666        public SqlDataReader RunPro_getdr(string proc_name,SqlParameter[] parames)
667        {
668            SqlCommand cmds = Create_cmd_pro(proc_name, parames);
669
670            SqlDataReader dataReader = null;
671
672            try
673            {
674                if (conn.State != ConnectionState.Open)   /**////不重复打开数据库连接
675                {
676                    conn.Open();
677                }
678                
679                dataReader = cmds.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
680
681            }
682            catch (Exception ex)
683            {
684                throw new Exception("出现异常" + ex.ToString());
685            }
686            finally
687            {
688                if (parames != null)
689                    cmds.Parameters.Clear();  /**////如果存在参数，那么就清空参数
690
691                ///CloseCon();                   ///释放连接数据库各项
692            }
693
694            return dataReader;
695
696        }
697
698        /**//// <summary>
699        /// 分页函数，返回dt
700        /// </summary>
701        /// <param name="table_name">需要分页显示的表名</param>
702        /// <param name="key">表的主键,必须唯一性</param>
703        /// <param name="orderstr">排序字段如f_Name asc或f_name desc(注意只能有一个排序字段)</param>
704        /// <param name="cpage">当前页</param>
705        /// <param name="psize">每页大小</param>
706        /// <param name="fieles">显示的字段列表</param>
707        /// <param name="filter">条件语句,不加where</param>
708        /// <param name="g_str">分组字段</param>
709        /// <returns>返回内存表</returns>
710        public DataTable Pagination_dt(string table_name, string key, string orderstr, int cpage, int psize, string fieles, string filter, string g_str,string pro_name)
711        {
712
713            DataTable dt = new DataTable();
714
715            SqlCommand cmd = Create_cmd_pro(pro_name, null);
716
717            SqlParameter[] parames = {new SqlParameter("@Tables", SqlDbType.VarChar, 50), new SqlParameter("@PrimaryKey", SqlDbType.VarChar, 10), new SqlParameter("@Sort", SqlDbType.VarChar, 50), new SqlParameter("@CurrentPage", SqlDbType.Int, 4), new SqlParameter("@PageSize", SqlDbType.Int, 4), new SqlParameter("@fields", SqlDbType.VarChar, 1000), new SqlParameter("@Filter", SqlDbType.VarChar, 1000),new SqlParameter("@Group",SqlDbType.VarChar,1000)};
718            
719            parames[0].Value = table_name;
720            parames[1].Value = key;
721            parames[2].Value = orderstr;
722            parames[3].Value = cpage;
723            parames[4].Value = psize;
724            parames[5].Value = fieles;
725            parames[6].Value = filter;
726            parames[7].Value = g_str;
727
728            foreach (SqlParameter parameter in parames)  /**////添加输入参数集合
729            {
730                cmd.Parameters.Add(parameter);
731            }
732
733            SqlParameter s1 = cmd.Parameters.Add(new SqlParameter("@TotalPage", SqlDbType.Int));
734            SqlParameter s2 = cmd.Parameters.Add(new SqlParameter("@TotalRecord", SqlDbType.Int));    /**////返回值
735            s1.Direction = ParameterDirection.Output;
736            s2.Direction = ParameterDirection.Output;
737
738            SqlDataReader dr = null;
739
740            try
741            {
742                if (conn.State != ConnectionState.Open)   /**////不重复打开数据库连接
743                {
744                    conn.Open();
745                }
746                dr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
747                if(dr.HasRows)
748                {
749                    dt.Load(dr);
750                    dr.Close();
751                    dr.Dispose();
752
753                    if (cmd.Parameters["@TotalRecord"].Value != System.DBNull.Value)
754                    {
755                       allrecord = int.Parse(cmd.Parameters["@TotalRecord"].Value.ToString()) ; /**////返回总记录数
756                    }
757                    else
758                    {
759                       allrecord = 0;
760                    }
761
762                    if (cmd.Parameters["@TotalPage"].Value != System.DBNull.Value) 
763                    {
764                       allpage = int.Parse(cmd.Parameters["@TotalPage"].Value.ToString());  /**////返回首页数
765                    }else{
766                       allpage = 0;
767                    }
768                }
769
770            }
771            catch(Exception ex)
772            {
773                throw new Exception("出现异常" + ex.ToString());
774            }
775            finally
776            {
777                CloseCon();
778            }
779
780            return dt;
781        }
782
783        #endregion
784
785        #endregion
786
787        " checksql SQL参数检测危险字符 "#region " checksql SQL参数检测危险字符 "
788        /**//// <summary>
789        /// Sql参数检测
790        /// </summary>
791        /// <param name="str">被检测的字符串</param>
792        /// <returns></returns>
793        public bool checksql(string str)
794        {
795            if (str == "" || str == null)
796            {
797                return false;
798            }
799            string charstr = "',;,*,%,and,exec,insert,select,count,chr,mid,master,truncate,char,declare";
800            string[] strarr = charstr.Split(',');
801            foreach (string i in strarr)
802            {
803                if (str.IndexOf(i) > -1)
804                {
805                    return false;
806                }
807            }
808            return true;
809        }
810        #endregion
811
812        " showpage 分页代码 "#region " showpage 分页代码 "
813        /**//// <summary>
814        /// url调整
815        /// </summary>
816        /// <param name="str"></param>
817        /// <returns></returns>
818        public string joinchar(string str)
819        {
820            if (str == "")
821            {
822                return "";
823            }
824
825            if (str.IndexOf("?") < str.Length)
826            {
827                if (str.IndexOf("?") > 1)
828                {
829                    if (str.IndexOf("&") < str.Length)
830                    {
831                        return str + "&";
832                    }
833                    else
834                    {
835                        return str;
836                    }
837                }
838                else
839                {
840                    return str + "?";
841                }
842            }
843
844            return str;
845        }
846
847        /**//// <summary>
848        /// 分页
849        /// </summary>
850        /// <param name="total">记录数</param>
851        /// <param name="pagenum">每页个数</param>
852        /// <param name="current">当前页</param>
853        /// <param name="url">叶面url</param>
854        /// <param name="unit">单位</param>
855        /// <returns></returns>
856        public string showpage(int total, int pagenum, int current, string url, string unit)
857        {
858            StringBuilder str = new StringBuilder();
859            StringBuilder str1 = new StringBuilder();
860
861            int page = 1;
862            if (total % pagenum == 0)
863            {
864                page = total / pagenum;
865            }
866            else
867            {
868                page = total / pagenum + 1;
869            }
870            url = joinchar(url);
871
872            if (page > 10)
873            {
874                if (current <= 5)
875                {
876                    for (int i = 1; i <= 9; i++)
877                    {
878                        if (i == current)
879                        {
880                            str.Append(" <b>[" + i + "]</b> ");
881                        }
882                        else
883                        {
884                            str.Append(" <a href='" + url + "page=" + i + "'>" + i + "</a> ");
885                        }
886                    }
887                    str.Append("" + " <a href='" + url + "page=" + page + "'>" + page + "</a> ");
888                }
889                else if (current >= page - 4)
890                {
891                    str.Append(" <a href='" + url + "page=1'>1</a> ");
892                    for (int i = page - 8; i <= page; i++)
893                    {
894                        if (i == current)
895                        {
896                            str.Append(" <b>[" + i + "]</b> ");
897                        }
898                        else
899                        {
900                            str.Append(" <a href='" + url + "page=" + i + "'>" + i + "</a> ");
901                        }
902                    }
903                }
904                else
905                {
906                    str.Append(" <a href='" + url + "page=1'>1</a> ");
907                    for (int i = current - 4; i <= current + 4; i++)
908                    {
909                        if (i == current)
910                        {
911                            str.Append(" <b>[" + i + "]</b> ");
912                        }
913                        else
914                        {
915                            str.Append(" <a href='" + url + "page=" + i + "'>" + i + "</a> ");
916                        }
917                    }
918                    str.Append("" + " <a href='" + url + "page=" + page + "'>" + page + "</a> ");
919                }
920            }
921            else
922            {
923                for (int i = 1; i <= page; i++)
924                {
925                    if (page != 1)
926                    {
927                        if (i == current)
928                        {
929                            str.Append(" <b>[" + i + "]</b> ");
930                        }
931                        else
932                        {
933                            str.Append(" <a href='" + url + "page=" + i + "'>" + i + "</a> ");
934                        }
935                    }
936                }
937            }
938            int down = current + 1;
939            int up = current - 1;
940            if (page > 1)
941            {
942                if (current == 1)
943                {
944                    str1.Append(" <a href='" + url + "page=2'>下一页</a>");
945                }
946                else if (current == page)
947                {
948                    str1.Append(" <a href='" + url + "page=" + up.ToString() + "'>上一页</a>");
949                }
950                else
951                {
952                    str1.Append(" <a href='" + url + "page=" + up.ToString() + "'>上一页</a> <a href='" + url + "page=" + down.ToString() + "'>下一页</a>");
953                }
954            }
955            if (page == 0) { page = 1; }
956
957            return "页次:" + current + "/" + page.ToString() + ",共" + total.ToString() + unit + " &nbsp; " + str1.ToString() + str.ToString();
958        }
959        #endregion
960
961        " IDisposable 成员 "#region " IDisposable 成员 "
962
963        /**//// <summary>
964        /// 强迫释放数据库连接
965        /// </summary>
966        public void Dispose()
967        {
968            Dispose(true);
969        }
970
971        /**//// <summary>
972        /// 类回收时，关闭数据库连接
973        /// </summary>
974        /// <param name="disposing"></param>
975        public void Dispose(bool disposing)
976        {
977            if (disposing)
978            {
979                CloseCon();
980            }
981            else
982            {
983                CloseCon();
984            }
985        }
986
987        #endregion
988
989    }
990    #endregion
991
992}
993
994#endregion
995