[SQL]通用的分頁存儲過程

------------------------------------------------------------
--
--通用的分頁存儲過程
--
-------------------------------------------------------------
CREATE PROCEDURE [dbo].[PageList]
(
@tblName     nvarchar(200),        ----要顯示的表或多個表的連接
@fldName     nvarchar(500) = '*',    ----要顯示的字段列表
@pageSize    int = 1,        ----每頁顯示的記錄個數
@page        int = 10,        ----要顯示那一頁的記錄
@fldSort    nvarchar(200) = null,    ----排序字段列表或條件
@Sort        bit = 0,        ----排序方法，0爲升序，1爲降序(如果是多字段排列Sort指代最後一個排序字段的排列順序(最後一個排序字段不加排序標記)--程序傳參如：' SortA Asc,SortB Desc,SortC ')
@strCondition    nvarchar(1000) = null,    ----查詢條件,不需where,以And開始
@ID        nvarchar(150),        ----主表的主鍵
@Dist                 bit = 0 ,          ----是否添加查詢字段的 DISTINCT 默認0不添加/1添加
@pageCount    int = 1 output,            ----查詢結果分頁後的總頁數
@Counts    int = 1 output,                ----查詢到的記錄數
@strSql          nvarchar(1000) = '' output  -----最後返回的SQL語句
)
AS
SET NOCOUNT ON
Declare @sqlTmp nvarchar(1000)        ----存放動態生成的SQL語句
Declare @strTmp nvarchar(1000)        ----存放取得查詢結果總數的查詢語句
Declare @strID     nvarchar(1000)        ----存放取得查詢開頭或結尾ID的查詢語句
Declare @strSortType nvarchar(10)    ----數據排序規則A
Declare @strFSortType nvarchar(10)    ----數據排序規則B
Declare @SqlSelect nvarchar(50)         ----對含有DISTINCT的查詢進行SQL構造
Declare @SqlCounts nvarchar(50)          ----對含有DISTINCT的總數查詢進行SQL構造
if @Dist  = 0
begin
    set @SqlSelect = 'select '
    set @SqlCounts = 'Count(*)'
end
else
begin
    set @SqlSelect = 'select distinct '
    set @SqlCounts = 'Count(DISTINCT '+@ID+')'
end
if @Sort=0
begin
    set @strFSortType=' ASC '
    set @strSortType=' DESC '
end
else
begin
    set @strFSortType=' DESC '
    set @strSortType=' ASC '
end
--------生成查詢語句--------
--此處@strTmp爲取得查詢結果數量的語句
if @strCondition is null or @strCondition=''     --沒有設置顯示條件
begin
    set @sqlTmp =  @fldName + ' From ' + @tblName
    set @strTmp = @SqlSelect+' @Counts='+@SqlCounts+' FROM '+@tblName
    set @strID = ' From ' + @tblName
end
else
begin
    set @sqlTmp = + @fldName + 'From ' + @tblName + ' where (1>0) ' + @strCondition
    set @strTmp = @SqlSelect+' @Counts='+@SqlCounts+' FROM '+@tblName + ' where (1>0) ' + @strCondition
    set @strID = ' From ' + @tblName + ' where (1>0) ' + @strCondition
end
----取得查詢結果總數量-----
exec sp_executesql @strTmp,N'@Counts int out ',@Counts out
declare @tmpCounts int
if @Counts = 0
    set @tmpCounts = 1
else
    set @tmpCounts = @Counts
    --取得分頁總數
    set @pageCount=(@tmpCounts+@pageSize-1)/@pageSize
    /**//**//**//**當前頁大於總頁數 取最後一頁**/
    if @page>@pageCount
        set @page=@pageCount
    --/*-----數據分頁2分處理-------*/
    declare @pageIndex int --總數/頁大小
    declare @lastcount int --總數%頁大小 
    set @pageIndex = @tmpCounts/@pageSize
    set @lastcount = @tmpCounts%@pageSize
    if @lastcount > 0
        set @pageIndex = @pageIndex + 1
    else
        set @lastcount = @pagesize
    --//***顯示分頁
    if @strCondition is null or @strCondition=''     --沒有設置顯示條件
    begin
        if @pageIndex<2 or @page<=@pageIndex / 2 + @pageIndex % 2   --前半部分數據處理
            begin 
                set @strTmp=@SqlSelect+' top '+ CAST(@pageSize as VARCHAR(4))+' '+ @fldName+' from '+@tblName
                        +' where '+@ID+' not in('+ @SqlSelect+' top '+ CAST(@pageSize*(@page-1) as Varchar(20)) +' '+ @ID +' from '+@tblName
                        +' order by '+ @fldSort +' '+ @strFSortType+')'
                        +' order by '+ @fldSort +' '+ @strFSortType 
            end
        else
            begin
            set @page = @pageIndex-@page+1 --後半部分數據處理
                if @page <= 1 --最後一頁數據顯示
                    set @strTmp=@SqlSelect+' * from ('+@SqlSelect+' top '+ CAST(@lastcount as VARCHAR(4))+' '+ @fldName+' from '+@tblName
                        +' order by '+ @fldSort +' '+ @strSortType+') AS TempTB'+' order by '+ @fldSort +' '+ @strFSortType 
                else                
                    set @strTmp=@SqlSelect+' * from ('+@SqlSelect+' top '+ CAST(@pageSize as VARCHAR(4))+' '+ @fldName+' from '+@tblName
                        +' where '+@ID+' not in('+ @SqlSelect+' top '+ CAST(@pageSize*(@page-2)+@lastcount as Varchar(20)) +' '+ @ID +' from '+@tblName
                        +' order by '+ @fldSort +' '+ @strSortType+')'
                        +' order by '+ @fldSort +' '+ @strSortType+') AS TempTB'+' order by '+ @fldSort +' '+ @strFSortType 
            end
    end
    else --有查詢條件
    begin
        if @pageIndex<2 or @page<=@pageIndex / 2 + @pageIndex % 2   --前半部分數據處理
        begin 
                set @strTmp=@SqlSelect+' top '+ CAST(@pageSize as VARCHAR(4))+' '+ @fldName +' from  '+@tblName
                    +' where '+@ID+' not in('+ @SqlSelect+' top '+ CAST(@pageSize*(@page-1) as Varchar(20)) +' '+ @ID +' from '+@tblName
                    +' Where (1>0) ' + @strCondition + ' order by '+ @fldSort +' '+ @strFSortType+')'
                    +' ' + @strCondition + ' order by '+ @fldSort +' '+ @strFSortType                 
        end
        else
        begin 
            set @page = @pageIndex-@page+1 --後半部分數據處理
            if @page <= 1 --最後一頁數據顯示
                    set @strTmp=@SqlSelect+' * from ('+@SqlSelect+' top '+ CAST(@lastcount as VARCHAR(4))+' '+ @fldName+' from '+@tblName
                        +' where (1>0) '+ @strCondition +' order by '+ @fldSort +' '+ @strSortType+') AS TempTB'+' order by '+ @fldSort +' '+ @strFSortType
            else
                    set @strTmp=@SqlSelect+' * from ('+@SqlSelect+' top '+ CAST(@pageSize as VARCHAR(4))+' '+ @fldName+' from '+@tblName
                        +' where '+@ID+' not in('+ @SqlSelect+' top '+ CAST(@pageSize*(@page-2)+@lastcount as Varchar(20)) +' '+ @ID +' from '+@tblName
                        +' where (1>0) '+ @strCondition +' order by '+ @fldSort +' '+ @strSortType+')'
                        + @strCondition +' order by '+ @fldSort +' '+ @strSortType+') AS TempTB'+' order by '+ @fldSort +' '+ @strFSortType 
        end    
    end
------返回查詢結果-----
set @strSql = @strTmp
exec sp_executesql @strTmp
--print @strTmp

 

 數據庫基類

 

//------------------------------------------------------------------------------
// 創建標識: Copyright (C) 2007 Socansoft.com 版權所有
// 創建描述: SocanCode代碼生成器自動創建
//
// 功能描述: 數據庫操作基類
//
// 修改標識:
// 修改描述:
//------------------------------------------------------------------------------

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Data;
using System.Text;
using System.Data.SqlClient;
using System.Configuration;
using System.Collections;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
using System.Xml;
using System.Reflection;


namespace DBUtility
...{
    /**//// <summary>
    /// 數據訪問基礎類(基於SQLServer)
    /// </summary>
    public abstract class SqlHelper
    ...{
        //數據庫連接字符串(web.config來配置)
        public static readonly string LocalSqlServer = ConfigurationManager.ConnectionStrings["LocalSqlServer"].ConnectionString;

        /**//// <summary>
        /// 通用分頁存儲過程
        /// </summary>
        /// <param name="connectionString">連接</param>
        /// <param name="tblName">要顯示的表或多個表的連接</param>
        /// <param name="fldName">要顯示的字段列表,可爲Null,表示*</param>
        /// <param name="pageSize">每頁顯示的記錄個數</param>
        /// <param name="pageIndex">要顯示那一頁的記錄</param>
        /// <param name="fldSort">排序字段列表或條件</param>
        /// <param name="Sort">排序方法，False爲升序，True爲降序(如果是多字段排列Sort指代最後一個排序字段的排列順序(最後一個排序字段不加排序標記)--程序傳參如：' SortA Asc,SortB Desc,SortC ')</param>
        /// <param name="strCondition">查詢條件,不需where,以And開始,可爲Null,表示""</param>
        /// <param name="ID">主表的主鍵</param>
        /// <param name="Disk">是否添加查詢字段的 DISTINCT 默認False不添加/True添加</param>
        /// <param name="pageCount">查詢結果分頁後的總頁數</param>
        /// <param name="Counts">查詢到的記錄數</param>
        /// <param name="strSql">最後返回的SQL語句</param>
        /// <returns>查詢當前頁的數據集</returns>
        public static DataSet PageList(string connectionString, string tblName, string fldName, int pageSize, int pageIndex,
            string fldSort, bool Sort, string strCondition, string ID, bool Dist,
            out int pageCount, out int Counts, out string strSql)
        ...{
            SqlParameter[] parameters =...{ new SqlParameter("@tblName",SqlDbType.NVarChar,200),
                new SqlParameter("@fldName",SqlDbType.NVarChar,500),
                new SqlParameter("@pageSize",SqlDbType.Int),
                new SqlParameter("@page",SqlDbType.Int),
                new SqlParameter("@fldSort",SqlDbType.NVarChar,200),
                new SqlParameter("@Sort",SqlDbType.Bit),
                new SqlParameter("@strCondition",SqlDbType.NVarChar,1000),
                new SqlParameter("@ID",SqlDbType.NVarChar,150),
                new SqlParameter("@Dist",SqlDbType.Bit),
                new SqlParameter("@pageCount",SqlDbType.Int),
                new SqlParameter("@Counts",SqlDbType.Int),
                new SqlParameter("@strSql",SqlDbType.NVarChar,1000)};

            parameters[0].Value = tblName;
            parameters[1].Value = (fldName == null) ? "*" : fldName;
            parameters[2].Value = (pageSize == 0) ? int.Parse(ConfigurationManager.AppSettings["PageSize"]) : pageSize;
            parameters[3].Value = pageIndex;
            parameters[4].Value = fldSort;
            parameters[5].Value = Sort;
            parameters[6].Value = strCondition == null ? "" : strCondition;
            parameters[7].Value = ID;
            parameters[8].Value = Dist;
            parameters[9].Direction = ParameterDirection.Output;
            parameters[10].Direction = ParameterDirection.Output;
            parameters[11].Direction = ParameterDirection.Output;

            DataSet ds = RunProcedure(connectionString, "PageList", parameters, "ds");

            pageCount = (int)parameters[9].Value;
            Counts = (int)parameters[10].Value;
            strSql = parameters[11].Value.ToString();
            return ds;
        }

        執行簡單SQL語句#region 執行簡單SQL語句
        /**//// <summary>
        /// 獲取表某個字段的最大值
        /// </summary>
        /// <param name="FieldName"></param>
        /// <param name="TableName"></param>
        /// <returns></returns>
        public static int GetMaxID(string connectionString, string FieldName, string TableName)
        ...{
            string strSql = "select max(" + FieldName + ") from " + TableName;
            DataSet ds = Query(connectionString, strSql);
            if (ds.Tables[0].Rows[0][0] != DBNull.Value)
                return int.Parse(ds.Tables[0].Rows[0][0].ToString());
            else
                return 0;
        }

        /**//// <summary>
        ///  檢測一個記錄是否存在(SqlParameter語句方式)
        /// </summary>
        /// <param name="strSql"></param>
        /// <param name="cmdParms"></param>
        /// <returns></returns>
        public static bool Exists(string connectionString, string strSql, params SqlParameter[] cmdParms)
        ...{
            DataSet ds = Query(connectionString, strSql, cmdParms);
            return int.Parse(ds.Tables[0].Rows[0][0].ToString()) > 0;
        }

        /**//// <summary>
        /// 執行SQL語句，返回影響的記錄數
        /// </summary>
        /// <param name="SQLString">SQL語句</param>
        /// <returns>影響的記錄數</returns>
        public static int ExecuteSql(string connectionString, string SQLString)
        ...{
            using (SqlConnection connection = new SqlConnection(connectionString))
            ...{
                using (SqlCommand cmd = new SqlCommand(SQLString, connection))
                ...{
                    try
                    ...{
                        connection.Open();
                        int rows = cmd.ExecuteNonQuery();
                        return rows;
                    }
                    catch (System.Data.SqlClient.SqlException E)
                    ...{
                        connection.Close();
                        throw new Exception(E.Message);
                    }
                }
            }
        }
        /**//// <summary>
        /// 執行SQL語句，返回記錄的個數
        /// </summary>
        /// <param name="SQLString">SQL語句</param>
        /// <returns>影響的記錄數</returns>
        public static int ExecuteCountSql(string connectionString, string SQLString)
        ...{
            using (SqlConnection connection = new SqlConnection(connectionString))
            ...{
                using (SqlCommand cmd = new SqlCommand(SQLString, connection))
                ...{
                    try
                    ...{
                        connection.Open();
                        SqlDataReader dr = cmd.ExecuteReader();
                        dr.Read();
                        int count = int.Parse(dr[0].ToString());
                        return count;
                    }
                    catch (System.Data.SqlClient.SqlException E)
                    ...{
                        connection.Close();
                        throw new Exception(E.Message);
                    }
                }
            }
        }

        /**//// <summary>
        /// 執行多條SQL語句，實現數據庫事務。
        /// </summary>
        /// <param name="SQLStringList">多條SQL語句</param>        
        public static void ExecuteSqlTran(string connectionString, List<string> SQLStringList)
        ...{
            using (SqlConnection conn = new SqlConnection(connectionString))
            ...{
                conn.Open();
                SqlCommand cmd = new SqlCommand();
                cmd.Connection = conn;
                SqlTransaction tx = conn.BeginTransaction();
                cmd.Transaction = tx;
                try
                ...{
                    for (int n = 0; n < SQLStringList.Count; n++)
                    ...{
                        string strsql = SQLStringList[n].ToString();
                        if (strsql.Trim().Length > 1)
                        ...{
                            cmd.CommandText = strsql;
                            cmd.ExecuteNonQuery();
                        }
                    }
                    tx.Commit();
                }
                catch (System.Data.SqlClient.SqlException E)
                ...{
                    tx.Rollback();
                    throw new Exception(E.Message);
                }
            }
        }

        /**//// <summary>
        /// 執行帶一個存儲過程參數的的SQL語句。
        /// </summary>
        /// <param name="SQLString">SQL語句</param>
        /// <param name="content">參數內容,比如一個字段是格式複雜的文章，有特殊符號，可以通過這個方式添加</param>
        /// <returns>影響的記錄數</returns>
        public static int ExecuteSql(string connectionString, string SQLString, string content)
        ...{
            using (SqlConnection connection = new SqlConnection(connectionString))
            ...{
                SqlCommand cmd = new SqlCommand(SQLString, connection);
                System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@content", SqlDbType.NText);
                myParameter.Value = content;
                cmd.Parameters.Add(myParameter);
                try
                ...{
                    connection.Open();
                    int rows = cmd.ExecuteNonQuery();
                    return rows;
                }
                catch (System.Data.SqlClient.SqlException E)
                ...{
                    throw new Exception(E.Message);
                }
                finally
                ...{
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }

        /**//// <summary>
        /// 向數據庫裏插入圖像格式的字段(和上面情況類似的另一種實例)
        /// </summary>
        /// <param name="strSQL">SQL語句</param>
        /// <param name="fs">圖像字節,數據庫的字段類型爲image的情況</param>
        /// <returns>影響的記錄數</returns>
        public static int ExecuteSqlInsertImg(string connectionString, string strSQL, byte[] fs)
        ...{
            using (SqlConnection connection = new SqlConnection(connectionString))
            ...{
                SqlCommand cmd = new SqlCommand(strSQL, connection);
                System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@fs", SqlDbType.Image);
                myParameter.Value = fs;
                cmd.Parameters.Add(myParameter);
                try
                ...{
                    connection.Open();
                    int rows = cmd.ExecuteNonQuery();
                    return rows;
                }
                catch (System.Data.SqlClient.SqlException E)
                ...{
                    throw new Exception(E.Message);
                }
                finally
                ...{
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }

        /**//// <summary>
        /// 執行一條計算查詢結果語句，返回查詢結果（object）。
        /// </summary>
        /// <param name="SQLString">計算查詢結果語句</param>
        /// <returns>查詢結果（object）</returns>
        public static object GetSingle(string connectionString, string SQLString)
        ...{
            using (SqlConnection connection = new SqlConnection(connectionString))
            ...{
                using (SqlCommand cmd = new SqlCommand(SQLString, connection))
                ...{
                    try
                    ...{
                        connection.Open();
                        object obj = cmd.ExecuteScalar();
                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                        ...{
                            return null;
                        }
                        else
                        ...{
                            return obj;
                        }
                    }
                    catch (System.Data.SqlClient.SqlException e)
                    ...{
                        connection.Close();
                        throw new Exception(e.Message);
                    }
                }
            }
        }

        /**//// <summary>
        /// 執行查詢語句，返回SqlDataReader
        /// </summary>
        /// <param name="strSQL">查詢語句</param>
        /// <returns>SqlDataReader</returns>
        public static SqlDataReader ExecuteReader(string connectionString, string strSQL)
        ...{
            SqlConnection connection = new SqlConnection(connectionString);
            SqlCommand cmd = new SqlCommand(strSQL, connection);
            try
            ...{
                connection.Open();
                SqlDataReader myReader = cmd.ExecuteReader();
                return myReader;
            }
            catch (System.Data.SqlClient.SqlException e)
            ...{
                throw new Exception(e.Message);
            }
        }

        /**//// <summary>
        /// 執行查詢語句，返回DataSet
        /// </summary>
        /// <param name="SQLString">查詢語句</param>
        /// <returns>DataSet</returns>
        public static DataSet Query(string connectionString, string SQLString)
        ...{
            if (SQLString != null && SQLString.Trim() != "")
            ...{
                using (SqlConnection connection = new SqlConnection(connectionString))
                ...{
                    DataSet ds = new DataSet();
                    try
                    ...{
                        connection.Open();
                        SqlDataAdapter command = new SqlDataAdapter(SQLString, connection);
                        command.Fill(ds, "ds");
                    }
                    catch (System.Data.SqlClient.SqlException ex)
                    ...{
                        throw new Exception(ex.Message);
                    }
                    return ds;
                }
            }
            else
            ...{
                return null;
            }
        }

        #endregion 執行簡單SQL語句

        執行帶參數的SQL語句#region 執行帶參數的SQL語句

        /**//// <summary>
        /// 執行SQL語句，返回影響的記錄數
        /// </summary>
        /// <param name="SQLString">SQL語句</param>
        /// <returns>影響的記錄數</returns>
        public static int ExecuteSql(string connectionString, string SQLString, params SqlParameter[] cmdParms)
        ...{
            using (SqlConnection connection = new SqlConnection(connectionString))
            ...{
                using (SqlCommand cmd = new SqlCommand())
                ...{
                    try
                    ...{
                        PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                        int rows = cmd.ExecuteNonQuery();
                        cmd.Parameters.Clear();
                        return rows;
                    }
                    catch (System.Data.SqlClient.SqlException E)
                    ...{
                        throw new Exception(E.Message);
                    }
                }
            }
        }


        /**//// <summary>
        /// 執行多條SQL語句，實現數據庫事務。
        /// </summary>
        /// <param name="SQLStringList">SQL語句的哈希表（key爲sql語句，value是該語句的SqlParameter[]）</param>
        public static void ExecuteSqlTran(string connectionString, Hashtable SQLStringList)
        ...{
            using (SqlConnection conn = new SqlConnection(connectionString))
            ...{
                conn.Open();
                using (SqlTransaction trans = conn.BeginTransaction())
                ...{
                    SqlCommand cmd = new SqlCommand();
                    try
                    ...{
                        //循環
                        foreach (DictionaryEntry myDE in SQLStringList)
                        ...{
                            string cmdText = myDE.Key.ToString();
                            SqlParameter[] cmdParms = (SqlParameter[])myDE.Value;
                            PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
                            int val = cmd.ExecuteNonQuery();
                            cmd.Parameters.Clear();

                            trans.Commit();
                        }
                    }
                    catch
                    ...{
                        trans.Rollback();
                        throw;
                    }
                }
            }
        }

        /**//// <summary>
        /// 執行一條計算查詢結果語句，返回查詢結果（object）。
        /// </summary>
        /// <param name="SQLString">計算查詢結果語句</param>
        /// <returns>查詢結果（object）</returns>
        public static object GetSingle(string connectionString, string SQLString, params SqlParameter[] cmdParms)
        ...{
            using (SqlConnection connection = new SqlConnection(connectionString))
            ...{
                using (SqlCommand cmd = new SqlCommand())
                ...{
                    try
                    ...{
                        PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                        object obj = cmd.ExecuteScalar();
                        cmd.Parameters.Clear();
                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                        ...{
                            return null;
                        }
                        else
                        ...{
                            return obj;
                        }
                    }
                    catch (System.Data.SqlClient.SqlException e)
                    ...{
                        throw new Exception(e.Message);
                    }
                }
            }
        }

        /**//// <summary>
        /// 執行查詢語句，返回SqlDataReader
        /// </summary>
        /// <param name="strSQL">查詢語句</param>
        /// <returns>SqlDataReader</returns>
        public static SqlDataReader ExecuteReader(string connectionString, string SQLString, params SqlParameter[] cmdParms)
        ...{
            SqlConnection connection = new SqlConnection(connectionString);
            SqlCommand cmd = new SqlCommand();
            try
            ...{
                PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                SqlDataReader myReader = cmd.ExecuteReader();
                cmd.Parameters.Clear();
                return myReader;
            }
            catch (System.Data.SqlClient.SqlException e)
            ...{
                throw new Exception(e.Message);
            }

        }

        /**//// <summary>
        /// 執行查詢語句，返回DataSet
        /// </summary>
        /// <param name="SQLString">查詢語句</param>
        /// <returns>DataSet</returns>
        public static DataSet Query(string connectionString, string SQLString, params SqlParameter[] cmdParms)
        ...{
            using (SqlConnection connection = new SqlConnection(connectionString))
            ...{
                SqlCommand cmd = new SqlCommand();
                PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                using (SqlDataAdapter da = new SqlDataAdapter(cmd))
                ...{
                    DataSet ds = new DataSet();
                    try
                    ...{
                        da.Fill(ds, "ds");
                        cmd.Parameters.Clear();
                    }
                    catch (System.Data.SqlClient.SqlException ex)
                    ...{
                        throw new Exception(ex.Message);
                    }
                    return ds;
                }
            }
        }

        private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, string cmdText, SqlParameter[] cmdParms)
        ...{
            if (conn.State != ConnectionState.Open)
            ...{
                conn.Open();
            }
            cmd.Connection = conn;
            cmd.CommandText = cmdText;
            if (trans != null)
                cmd.Transaction = trans;
            cmd.CommandType = CommandType.Text;//cmdType;
            if (cmdParms != null)
            ...{
                foreach (SqlParameter parm in cmdParms)
                ...{
                    if (parm.SqlDbType == SqlDbType.DateTime)
                    ...{
                        if ((DateTime)parm.Value == DateTime.MinValue)
                            parm.Value = System.DBNull.Value;
                    }
                    cmd.Parameters.Add(parm);
                }
            }
        }

        #endregion 執行帶參數的SQL語句

        存儲過程操作#region 存儲過程操作

        /**//// <summary>
        /// 執行存儲過程
        /// </summary>
        /// <param name="storedProcName">存儲過程名</param>
        /// <param name="parameters">存儲過程參數</param>
        /// <returns>SqlDataReader</returns>
        public static SqlDataReader RunProcedure(string connectionString, string storedProcName, IDataParameter[] parameters)
        ...{
            SqlConnection connection = new SqlConnection(connectionString);
            SqlDataReader returnReader;
            connection.Open();
            SqlCommand command = BuildQueryCommand(connection, storedProcName, parameters);
            command.CommandType = CommandType.StoredProcedure;
            returnReader = command.ExecuteReader();
            return returnReader;
        }

        /**//// <summary>
        /// 執行存儲過程
        /// </summary>
        /// <param name="storedProcName">存儲過程名</param>
        /// <param name="parameters">存儲過程參數</param>
        /// <param name="tableName">DataSet結果中的表名</param>
        /// <returns>DataSet</returns>
        public static DataSet RunProcedure(string connectionString, string storedProcName, IDataParameter[] parameters, string tableName)
        ...{
            using (SqlConnection connection = new SqlConnection(connectionString))
            ...{
                DataSet dataSet = new DataSet();
                connection.Open();
                SqlDataAdapter sqlDA = new SqlDataAdapter();
                sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);
                sqlDA.Fill(dataSet, tableName);
                connection.Close();
                return dataSet;
            }
        }

        /**//// <summary>
        /// 構建 SqlCommand 對象(用來返回一個結果集，而不是一個整數值)
        /// </summary>
        /// <param name="connection">數據庫連接</param>
        /// <param name="storedProcName">存儲過程名</param>
        /// <param name="parameters">存儲過程參數</param>
        /// <returns>SqlCommand</returns>
        private static SqlCommand BuildQueryCommand(SqlConnection connection, string storedProcName, IDataParameter[] parameters)
        ...{
            SqlCommand command = new SqlCommand(storedProcName, connection);
            command.CommandType = CommandType.StoredProcedure;
            if (parameters != null)
            ...{
                foreach (SqlParameter parameter in parameters)
                ...{
                    if (parameter.SqlDbType == SqlDbType.DateTime)
                    ...{
                        if ((DateTime)parameter.Value == DateTime.MinValue)
                            parameter.Value = System.DBNull.Value;
                    }
                    command.Parameters.Add(parameter);
                }
            }
            return command;
        }

        /**//// <summary>
        /// 執行存儲過程，返回影響的行數        
        /// </summary>
        /// <param name="storedProcName">存儲過程名</param>
        /// <param name="parameters">存儲過程參數</param>
        /// <param name="rowsAffected">影響的行數</param>
        /// <returns></returns>
        public static int RunProcedure(string connectionString, string storedProcName, IDataParameter[] parameters, out int rowsAffected)
        ...{
            using (SqlConnection connection = new SqlConnection(connectionString))
            ...{
                int result;
                connection.Open();
                SqlCommand command = BuildIntCommand(connection, storedProcName, parameters);
                rowsAffected = command.ExecuteNonQuery();
                result = (int)command.Parameters["ReturnValue"].Value;
                connection.Close();
                return result;
            }
        }

        /**//// <summary>
        /// 創建 SqlCommand 對象實例(用來返回一個整數值)    
        /// </summary>
        /// <param name="storedProcName">存儲過程名</param>
        /// <param name="parameters">存儲過程參數</param>
        /// <returns>SqlCommand 對象實例</returns>
        private static SqlCommand BuildIntCommand(SqlConnection connection, string storedProcName, IDataParameter[] parameters)
        ...{
            SqlCommand command = BuildQueryCommand(connection, storedProcName, parameters);
            command.Parameters.Add(new SqlParameter("ReturnValue",
                SqlDbType.Int, 4, ParameterDirection.ReturnValue,
                false, 0, 0, string.Empty, DataRowVersion.Default, null));
            return command;
        }

        #endregion 存儲過程操作

        構造語句常用類#region 構造語句常用類
        /**//// <summary>
        /// Make input param.
        /// </summary>
        /// <param name="ParamName">Name of param.</param>
        /// <param name="DbType">Param type.</param>
        /// <param name="Size">Param size.</param>
        /// <param name="Value">Param value.</param>
        /// <returns>New parameter.</returns>
        public static SqlParameter MakeInParam(string ParamName, SqlDbType DbType, int Size, object Value)
        ...{
            return MakeParam(ParamName, DbType, Size, ParameterDirection.Input, Value);
        }
        public static SqlParameter MakeInParam(string ParamName, SqlDbType DbType, object Value)
        ...{
            return MakeParam(ParamName, DbType, 0, ParameterDirection.Input, Value);
        }

        /**//// <summary>
        /// Make input param.
        /// </summary>
        /// <param name="ParamName">Name of param.</param>
        /// <param name="DbType">Param type.</param>
        /// <param name="Size">Param size.</param>
        /// <returns>New parameter.</returns>
        public static SqlParameter MakeOutParam(string ParamName, SqlDbType DbType, int Size)
        ...{
            return MakeParam(ParamName, DbType, Size, ParameterDirection.Output, null);
        }

        /**//// <summary>
        /// Make stored procedure param.
        /// </summary>
        /// <param name="ParamName">Name of param.</param>
        /// <param name="DbType">Param type.</param>
        /// <param name="Size">Param size.</param>
        /// <param name="Direction">Parm direction.</param>
        /// <param name="Value">Param value.</param>
        /// <returns>New parameter.</returns>
        public static SqlParameter MakeParam(string ParamName, SqlDbType DbType, Int32 Size, ParameterDirection Direction, object Value)
        ...{
            SqlParameter param;

            if (Size > 0)
                param = new SqlParameter(ParamName, DbType, Size);
            else
                param = new SqlParameter(ParamName, DbType);

            param.Direction = Direction;
            if (!(Direction == ParameterDirection.Output && Value == null))
                param.Value = Value;

            return param;
        }
        #endregion 構造語句常用類

        由Object取值#region 由Object取值
        /**//// <summary>
        /// 取得Int值
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static int GetInt(object obj)
        ...{
            if (obj.ToString() != "")
                return int.Parse(obj.ToString());
            else
                return 0;
        }

        /**//// <summary>
        /// 獲得Long值
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static long GetLong(object obj)
        ...{
            if (obj.ToString() != "")
                return long.Parse(obj.ToString());
            else
                return 0;
        }

        /**//// <summary>
        /// 取得Decimal值
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static decimal GetDecimal(object obj)
        ...{
            if (obj.ToString() != "")
                return decimal.Parse(obj.ToString());
            else
                return 0;
        }

        /**//// <summary>
        /// 取得Guid值
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static Guid GetGuid(object obj)
        ...{
            if (obj.ToString() != "")
                return new Guid(obj.ToString());
            else
                return Guid.Empty;
        }

        /**//// <summary>
        /// 取得DateTime值
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static DateTime GetDateTime(object obj)
        ...{
            if (obj.ToString() != "")
                return DateTime.Parse(obj.ToString());
            else
                return DateTime.MinValue;
        }

        /**//// <summary>
        /// 取得bool值
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static bool GetBool(object obj)
        ...{
            if (obj.ToString() == "1" || obj.ToString().ToLower() == "true")
                return true;
            else
                return false;
        }

        /**//// <summary>
        /// 取得byte[]
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static Byte[] GetByte(object obj)
        ...{
            if (obj.ToString() != "")
            ...{
                return (Byte[])obj;
            }
            else
                return null;
        }

        /**//// <summary>
        /// 取得string值
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static string GetString(object obj)
        ...{
            return obj.ToString();
        }
        #endregion

        序列化與反序列化#region 序列化與反序列化
        /**//// <summary>
        /// 序列化對象
        /// </summary>
        /// <param name="obj">要序列化的對象</param>
        /// <returns>返回二進制</returns>
        public static byte[] SerializeModel(Object obj)
        ...{
            if (obj != null)
            ...{
                BinaryFormatter binaryFormatter = new BinaryFormatter();
                MemoryStream ms = new MemoryStream();
                byte[] b;
                binaryFormatter.Serialize(ms, obj);
                ms.Position = 0;
                b = new Byte[ms.Length];
                ms.Read(b, 0, b.Length);
                ms.Close();
                return b;
            }
            else
                return new byte[0];
        }

        /**//// <summary>
        /// 反序列化對象
        /// </summary>
        /// <param name="b">要反序列化的二進制</param>
        /// <returns>返回對象</returns>
        public static object DeserializeModel(byte[] b, object SampleModel)
        ...{
            if (b == null || b.Length == 0)
                return SampleModel;
            else
            ...{
                object result = new object();
                BinaryFormatter binaryFormatter = new BinaryFormatter();
                MemoryStream ms = new MemoryStream();
                try
                ...{
                    ms.Write(b, 0, b.Length);
                    ms.Position = 0;
                    result = binaryFormatter.Deserialize(ms);
                    ms.Close();
                }
                catch ...{ }
                return result;
            }
        }
        #endregion

        Model與XML互相轉換#region Model與XML互相轉換
        /**//// <summary>
        /// Model轉化爲XML的方法
        /// </summary>
        /// <param name="model">要轉化的Model</param>
        /// <returns></returns>
        public static string ModelToXML(object model)
        ...{
            XmlDocument xmldoc = new XmlDocument();
            XmlElement ModelNode = xmldoc.CreateElement("Model");
            xmldoc.AppendChild(ModelNode);

            if (model != null)
            ...{
                foreach (PropertyInfo property in model.GetType().GetProperties())
                ...{
                    XmlElement attribute = xmldoc.CreateElement(property.Name);
                    if (property.GetValue(model, null) != null)
                        attribute.InnerText = property.GetValue(model, null).ToString();
                    else
                        attribute.InnerText = "[Null]";
                    ModelNode.AppendChild(attribute);
                }
            }

            return xmldoc.OuterXml;
        }

        /**//// <summary>
        /// XML轉化爲Model的方法
        /// </summary>
        /// <param name="xml">要轉化的XML</param>
        /// <param name="SampleModel">Model的實體示例，New一個出來即可</param>
        /// <returns></returns>
        public static object XMLToModel(string xml, object SampleModel)
        ...{
            if (string.IsNullOrEmpty(xml))
                return SampleModel;
            else
            ...{
                XmlDocument xmldoc = new XmlDocument();
                xmldoc.LoadXml(xml);

                XmlNodeList attributes = xmldoc.SelectSingleNode("Model").ChildNodes;
                foreach (XmlNode node in attributes)
                ...{
                    foreach (PropertyInfo property in SampleModel.GetType().GetProperties())
                    ...{
                        if (node.Name == property.Name)
                        ...{
                            if (node.InnerText != "[Null]")
                            ...{
                                if (property.PropertyType == typeof(System.Guid))
                                    property.SetValue(SampleModel, new Guid(node.InnerText), null);
                                else
                                    property.SetValue(SampleModel, Convert.ChangeType(node.InnerText, property.PropertyType), null);
                            }
                            else
                                property.SetValue(SampleModel, null, null);
                        }
                    }
                }
                return SampleModel;
            }
        }
        #endregion
    }
}