C# 最牛逼的Utility工具類

完整代碼:

 

using System;
using System.Collections.Specialized;
using System.IO;
using System.Net;
using System.Text;
using System.Text.RegularExpressions;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Security.Cryptography.X509Certificates;
using System.Net.Security;
using System.Reflection;
using System.ComponentModel;

namespace DBUtility
{
   public class DButility
    {
        private static Random ran = new Random();
        private static readonly int TIMEOUT = 5000;
        #region DBNull類型轉換
        public static long ToInt64(object value)
        {
            return (Convert.IsDBNull(value)) ? 0 : Convert.ToInt64(value);
        }

        public static int ToInt32(object value)
        {
            return (Convert.IsDBNull(value)) ? 0 : Convert.ToInt32(value);
        }

        public static short ToInt16(object value)
        {
            return (Convert.IsDBNull(value)) ? (short)0 : Convert.ToInt16(value);
        }

        public static string ToString(object value)
        {
            return value.ToString();
        }

        public static decimal ToDecimal(object value)
        {
            return (Convert.IsDBNull(value)) ? 0 : Convert.ToDecimal(value);
        }

        public static DateTime ToDateTime(object value)
        {
            return (Convert.IsDBNull(value)) ? DateTime.MinValue : Convert.ToDateTime(value);
        }
        #endregion

        #region AES 加密/解密
        /// <summary>
        ///  AES 加密
        /// </summary>
        /// <param name="str">明文（待加密）</param>
        /// <param name="key">密文</param>
        /// <returns></returns>
        public static string AesEncryptToHex(string str, string key)
        {
            if (string.IsNullOrEmpty(str)) return null;
            Byte[] toEncryptArray = Encoding.UTF8.GetBytes(str);   //命名空間： using System.Text;

            System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged
            {
                Key = Encoding.UTF8.GetBytes(key),
                Mode = System.Security.Cryptography.CipherMode.ECB,
                Padding = System.Security.Cryptography.PaddingMode.PKCS7
            };

            System.Security.Cryptography.ICryptoTransform cTransform = rm.CreateEncryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

            var hex = BitConverter.ToString(resultArray, 0).Replace("-", string.Empty).ToLower();
            return hex;
        }

        /// <summary>
        ///  AES 解密
        /// </summary>
        /// <param name="str">明文（待解密）</param>
        /// <param name="key">密文</param>
        /// <returns></returns>
        public static string AesDecryptFromHex(string str, string key)
        {
            if (string.IsNullOrEmpty(str)) return null;
            var toEncryptArray = new byte[str.Length / 2];
            for (var x = 0; x < toEncryptArray.Length; x++)
            {
                var i = Convert.ToInt32(str.Substring(x * 2, 2), 16);
                toEncryptArray[x] = (byte)i;
            }

            //Byte[] toEncryptArray = Convert.FromBase64String(str);

            System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged
            {
                Key = Encoding.UTF8.GetBytes(key),
                Mode = System.Security.Cryptography.CipherMode.ECB,
                Padding = System.Security.Cryptography.PaddingMode.PKCS7
            };

            System.Security.Cryptography.ICryptoTransform cTransform = rm.CreateDecryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

            return Encoding.UTF8.GetString(resultArray);
        }
        #endregion

        #region 獲取時間戳，取隨機數
        /// <summary>
        /// 獲取時間戳
        /// </summary>
        /// <returns></returns>
        public static long GetTimeStamp()
        {
            TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
            return Convert.ToInt64(ts.TotalSeconds);
        }

        /// <summary>
        /// 取隨機數
        /// </summary>
        /// <param name="min"></param>
        /// <param name="max"></param>
        /// <returns></returns>
        public static int GetRandom(int min, int max)
        {
            return ran.Next(min, max);
        }

        /// <summary>
        /// 獲取當前本地時間戳
        /// </summary>
        /// <returns></returns>
        public static long GetCurrentTimeUnix()
        {
            TimeSpan cha = (DateTime.Now - TimeZone.CurrentTimeZone.ToLocalTime(new System.DateTime(1970, 1, 1)));
            long t = (long)cha.TotalSeconds;
            return t;
        }

        /// <summary>
        /// 時間戳轉換為本地時間對象
        /// </summary>
        /// <returns></returns>
        public static DateTime GetUnixDateTime(long unix)
        {
            //long unix = 1500863191;
            DateTime dtStart = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));
            DateTime newTime = dtStart.AddSeconds(unix);
            return newTime;
        }

        /// <summary>
        /// Unicode轉字符串
        /// </summary>
        /// <param name="source">經過Unicode編碼的字符串</param>
        /// <returns>正常字符串</returns>
        public static string UnicodeToString(string source)
        {
            return new Regex(@"\\u([0-9A-F]{4})", RegexOptions.IgnoreCase | RegexOptions.Compiled).Replace(
                         source, x => string.Empty + Convert.ToChar(Convert.ToUInt16(x.Result("$1"), 16)));
        }

        /// <summary>
        /// Stream流轉化為字符串
        /// </summary>
        /// <returns></returns>
        public static string StreamToString(Stream stream)
        {
            if (stream == null || stream.Length == 0)
            {
                return string.Empty;
            }
            StreamReader sr = new StreamReader(stream);
            return sr.ReadToEnd();
        }

        /// <summary>
        /// RequestForm轉換成String, key=value格式
        /// </summary>
        /// <returns></returns>
        public static string RequestFormToString(NameValueCollection form)
        {
            if (form == null)
            {
                return null;
            }

            string strTemp = string.Empty;

            String[] requestItem = form.AllKeys;
            for (int i = 0; i < requestItem.Length; i++)
            {
                strTemp += requestItem[i] + "=" + form[requestItem[i]] + "&";
            }

            strTemp = strTemp.TrimEnd('&');
            return strTemp;
        }
        #endregion

        #region HttpUtils

        public static string HttpPost(string Url, string mobiles, string content)
        {
            string postData = string.Format("mobiles={0}&content={1}", mobiles, content);

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Url);
            System.Net.ServicePointManager.DefaultConnectionLimit = 200;
            request.Method = "POST";
            request.KeepAlive = false;
            request.ContentType = "application/x-www-form-urlencoded";
            request.ContentLength = Encoding.UTF8.GetByteCount(postData);
            Stream myRequestStream = request.GetRequestStream();
            StreamWriter myStreamWriter = new StreamWriter(myRequestStream, Encoding.GetEncoding("gb2312"));
            myStreamWriter.Write(postData, 0, postData.Length);
            myStreamWriter.Close();
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();

            Stream myResponseStream = response.GetResponseStream();
            StreamReader myStreamReader = new StreamReader(myResponseStream, Encoding.GetEncoding("utf-8"));
            string retString = myStreamReader.ReadToEnd();
            myStreamReader.Close();

            myResponseStream.Close();

            response = null;
            request = null;
            return retString;
        }



        /// <summary>  
        /// 指定Post地址使用Get 方式獲取全部字符串  
        /// </summary>  
        /// <param name="url">請求后台地址</param>  
        /// <returns></returns>  
        public static string Post(string url, Dictionary<string, string> dic)
        {
            string result = "";
            HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
            string mobiles = dic["mobiles"];
            string content = dic["content"];
            req.Method = "POST";
            req.ContentType = "application/x-www-form-urlencoded";
            #region 添加Post 參數
            StringBuilder builder = new StringBuilder();
            int i = 0;
            foreach (var item in dic)
            {
                if (i > 0)
                    builder.Append("&");
                builder.AppendFormat("{0}={1}", item.Key, item.Value);
                i++;
            }
            byte[] data = Encoding.UTF8.GetBytes(builder.ToString());
            req.ContentLength = data.Length;
            using (Stream reqStream = req.GetRequestStream())
            {
                reqStream.Write(data, 0, data.Length);
                reqStream.Close();
            }
            #endregion
            HttpWebResponse resp = (HttpWebResponse)req.GetResponse();
            Stream stream = resp.GetResponseStream();
            //獲取響應內容  
            using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
            {
                result = reader.ReadToEnd();
            }
            return result;
        }

        /// <summary>  
        /// 指定地址使用Get 方式獲取全部字符串  
        /// </summary>  
        /// <param name="url">請求后台地址</param>  
        /// <returns></returns>  
        public static string Get(string url, Dictionary<string, string> dic)
        {
            string result = "";
            HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
            string uname = dic["username"];
            string pwd = dic["password"];
            req.Method = "GET";
            req.ContentType = "application/x-www-form-urlencoded";
            HttpWebResponse resp = (HttpWebResponse)req.GetResponse();
            Stream stream = resp.GetResponseStream();
            //獲取響應內容  
            using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
            {
                result = reader.ReadToEnd();
            }
            return result;
        }

        public static string PostSend(string url, string param)
        {
            return PostSend(url, "UTF-8", param);
        }

        public static string PostSend(string url, string encoding, string param, string contentType = "application/x-www-form-urlencoded")
        {
            try
            {
                byte[] postData = Encoding.UTF8.GetBytes(param);

                HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
                Encoding myEncoding = Encoding.UTF8;
                request.Method = "POST";
                request.KeepAlive = false;
                request.AllowAutoRedirect = true;
                request.ContentType = contentType;
                request.UserAgent = "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727; .NET CLR  3.0.04506.648; .NET CLR 3.5.21022; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)";
                request.ContentLength = postData.Length;
                request.Timeout = TIMEOUT;

                System.IO.Stream outputStream = request.GetRequestStream();
                outputStream.Write(postData, 0, postData.Length);
                outputStream.Close();

                HttpWebResponse response = request.GetResponse() as HttpWebResponse;

                Stream responseStream = response.GetResponseStream();

                StreamReader reader = new System.IO.StreamReader(responseStream, Encoding.GetEncoding("UTF-8"));

                string retVal = reader.ReadToEnd();

                reader.Close();

                return retVal;
            }
            catch (Exception ex)
            {
                LogHelper.Error("PostSend [url:]" + url + " [params:]" + param + " [error:]" + ex.Message);
                return ex.Message;
            }
        }

        public static string PostSendWithCert(string url, string param)
        {
            return PostSendWithCert(url, "UTF-8", param);
        }

        public static string PostSendWithCert(string url, string encoding, string param, string contentType = "application/x-www-form-urlencoded")
        {
            try
            {
                string cert = System.Configuration.ConfigurationManager.AppSettings["CertPath"];
                string password = System.Configuration.ConfigurationManager.AppSettings["xcxMchId"];
                ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult);
                X509Certificate2 cer = new X509Certificate2(cert, password, X509KeyStorageFlags.PersistKeySet | X509KeyStorageFlags.MachineKeySet);

                byte[] postData = Encoding.UTF8.GetBytes(param);

                HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
                Encoding myEncoding = Encoding.UTF8;
                request.ClientCertificates.Add(cer);
                request.Method = "POST";
                request.KeepAlive = false;
                request.AllowAutoRedirect = true;
                request.ContentType = contentType;
                request.UserAgent = "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727; .NET CLR  3.0.04506.648; .NET CLR 3.5.21022; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)";
                request.ContentLength = postData.Length;
                request.Timeout = TIMEOUT;

                System.IO.Stream outputStream = request.GetRequestStream();
                outputStream.Write(postData, 0, postData.Length);
                outputStream.Close();

                HttpWebResponse response = request.GetResponse() as HttpWebResponse;

                Stream responseStream = response.GetResponseStream();

                StreamReader reader = new System.IO.StreamReader(responseStream, Encoding.GetEncoding("UTF-8"));

                string retVal = reader.ReadToEnd();

                reader.Close();

                return retVal;
            }
            catch (Exception ex)
            {
                LogHelper.Error("PostSend [url:]" + url + " [params:]" + param + " [error:]" + ex.Message);
                return ex.Message;
            }
        }

        /// <summary>
        /// 發請求獲取圖片到本地路徑
        /// </summary>
        /// <param name="url"></param>
        /// <param name="param"></param>
        /// <param name="pathName"></param>
        /// <param name="contentType"></param>
        public static void PostSaveToFile(string url, string param, string pathName, string contentType = "application/x-www-form-urlencoded")
        {
            try
            {
                byte[] postData = Encoding.UTF8.GetBytes(param);

                HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
                Encoding myEncoding = Encoding.UTF8;
                request.Method = "POST";
                request.KeepAlive = false;
                request.AllowAutoRedirect = true;
                request.ContentType = contentType;
                request.UserAgent = "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727; .NET CLR  3.0.04506.648; .NET CLR 3.5.21022; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)";
                request.ContentLength = postData.Length;
                request.Timeout = TIMEOUT;

                System.IO.Stream outputStream = request.GetRequestStream();
                outputStream.Write(postData, 0, postData.Length);
                outputStream.Close();

                HttpWebResponse response = request.GetResponse() as HttpWebResponse;

                Stream responseStream = response.GetResponseStream();

                System.Drawing.Image.FromStream(responseStream).Save(pathName);
            }
            catch (Exception ex)
            {
                LogHelper.Error("PostSend [url:]" + url + " [params:]" + param + " [error:]" + ex.Message);
            }
        }

        public static string HttpGet(string Url, string postDataStr = "")
        {
            try
            {
                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Url + (postDataStr == "" ? "" : "?") + postDataStr);
                // https
                if (Url.StartsWith("https", StringComparison.OrdinalIgnoreCase))
                {
                    ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult);
                    request.ProtocolVersion = HttpVersion.Version10;
                }

                request.Method = "GET";
                request.ContentType = "text/html;charset=UTF-8";
                request.Timeout = 3000;

                HttpWebResponse response = (HttpWebResponse)request.GetResponse();
                Stream myResponseStream = response.GetResponseStream();
                StreamReader myStreamReader = new StreamReader(myResponseStream, Encoding.GetEncoding("utf-8"));
                string retString = myStreamReader.ReadToEnd();
                myStreamReader.Close();
                myResponseStream.Close();

                return retString;
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                return null;
            }
        }

        private static bool CheckValidationResult(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors)
        {
            return true; //總是接受  
        }
        #endregion

        #region MD5加密

        /// <summary>
        /// 
        /// </summary>
        /// <param name="sDataIn"></param>
        /// <param name="move">給空即可</param>
        /// <returns></returns>
        public static string GetMD532(string sDataIn, string move)
        {
            System.Security.Cryptography.MD5CryptoServiceProvider md5 = new System.Security.Cryptography.MD5CryptoServiceProvider();
            byte[] bytValue, bytHash;
            bytValue = System.Text.Encoding.UTF8.GetBytes(move + sDataIn);
            bytHash = md5.ComputeHash(bytValue);
            md5.Clear();
            string sTemp = "";
            for (int i = 0; i < bytHash.Length; i++)
            {
                sTemp += bytHash[i].ToString("x").PadLeft(2, '0');
            }
            return sTemp;
        }

        public static string GetMD516(string ConvertString)
        {
            System.Security.Cryptography.MD5CryptoServiceProvider md5 = new System.Security.Cryptography.MD5CryptoServiceProvider();
            string t2 = BitConverter.ToString(md5.ComputeHash(UTF8Encoding.Default.GetBytes(ConvertString)), 4, 8);
            t2 = t2.Replace("-", "");

            t2 = t2.ToLower();

            return t2;
        }
        #endregion
    }
    #region log4net 日志類
    public class LogHelper
    {
        //在 <configuration></configuration>里面添加下面配置

        //      <configSections>
        //  <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler,log4net"/>
        //</configSections>

        //        <log4net>
        //  <logger name="logerror">
        //    <level value="ERROR"/>
        //    <appender-ref ref="ErrorAppender"/>
        //  </logger>
        //  <logger name="loginfo">
        //    <level value="INFO"/>
        //    <appender-ref ref="InfoAppender"/>
        //  </logger>
        //  <appender name="ErrorAppender" type="log4net.Appender.RollingFileAppender">
        //    <param name="File" value="Log\Error\"/>
        //    <param name="AppendToFile" value="true"/>
        //    <param name="CountDirection" value="-1"/>
        //    <param name="MaxSizeRollBackups" value="15"/>
        //    <param name="MaximumFileSize" value="5MB"/>
        //    <param name="lockingModel" type="log4net.Appender.FileAppender+MinimalLock"/>
        //    <rollingStyle value="Date"/>
        //    <datePattern value="yyyyMMdd'.txt'"/>
        //    <staticLogFileName value="false"/>
        //    <layout type="log4net.Layout.PatternLayout">
        //      <conversionPattern value="%d [%t]%c %m%n"/>
        //    </layout>
        //  </appender>
        //  <appender name="InfoAppender" type="log4net.Appender.RollingFileAppender">
        //    <param name="File" value="Log\Info\"/>
        //    <param name="AppendToFile" value="true"/>
        //    <param name="CountDirection" value="-1"/>
        //    <param name="MaxSizeRollBackups" value="15"/>
        //    <param name="MaximumFileSize" value="5MB"/>
        //    <param name="lockingModel" type="log4net.Appender.FileAppender+MinimalLock"/>
        //    <rollingStyle value="Date"/>
        //    <datePattern value="yyyyMMdd'.txt'"/>
        //    <staticLogFileName value="false"/>
        //    <layout type="log4net.Layout.PatternLayout">
        //      <conversionPattern value="%d [%t]%c %m%n"/>
        //    </layout>
        //  </appender>
        //</log4net>


        private static readonly log4net.ILog ILogInfo = log4net.LogManager.GetLogger("loginfo");  //添加log4net 引用

        public static readonly log4net.ILog ILogError = log4net.LogManager.GetLogger("logerror");

        public static void Info(string msg)
        {
            ILogInfo.Info(msg);
        }

        public static void Error(string msg)
        {
            ILogError.Error(msg);
        }

        /// <summary>
        /// 廢棄 改用FileNameError
        /// </summary>
        /// <param name="type"></param>
        /// <param name="msg"></param>
        public static void TypeError(string type, string msg)
        {
            // eg: type=Order, msg=數據庫更新失敗, OrderId:111222333
            //     msg:[Order] 數據庫更新失敗, OrderId:111222333
            ILogError.Error("[" + type + "] " + msg);
        }

        public static void FileNameInfo(string fileName, string msg)
        {
            ILogInfo.Info(fileName + " " + msg);
        }

        public static void FileNameError(string fileName, string msg)
        {
            ILogError.Error(fileName + " " + msg);
        }
    }
    #endregion

    #region DataTable,DataSet,list集合 互轉
    public class ModelHandler<T> where T : new()
    {
        #region DataSet=>List
        /// <summary>
        /// 填充對象列表：用DataSet的第一個表填充實體類
        /// </summary>
        /// <param name="ds">DataSet</param>
        /// <returns></returns>
        public List<T> FillModelByDataSet(DataSet ds)
        {
            if (ds == null || ds.Tables[0] == null || ds.Tables[0].Rows.Count == 0)
            {
                return null;
            }
            else
            {
                return FillModelByDataTable(ds.Tables[0]);
            }
        }
        #endregion

        #region DataTable=>List


        #region

        /// <summary>
        /// 類型枚舉
        /// </summary>
        private enum ModelType
        {
            //值類型
            Struct,

            Enum,

            //引用類型
            String,

            Object,
            Else
        }

        private static ModelType GetModelType(Type modelType)
        {
            //值類型
            if (modelType.IsEnum)
            {
                return ModelType.Enum;
            }
            //值類型
            if (modelType.IsValueType)
            {
                return ModelType.Struct;
            }
            //引用類型 特殊類型處理
            if (modelType == typeof(string))
            {
                return ModelType.String;
            }
            //引用類型 特殊類型處理
            return modelType == typeof(object) ? ModelType.Object : ModelType.Else;
        }

        #endregion

        /// <summary>  
        /// 填充對象列表：用DataTable填充實體類
        /// </summary>  
        public List<T> FillModelByDataTable(DataTable dt)
        {
            if (dt == null || dt.Rows.Count == 0)
            {
                return null;
            }
            List<T> modelList = new List<T>();
            foreach (DataRow dr in dt.Rows)
            {
                //T model = (T)Activator.CreateInstance(typeof(T));  
                T model = new T();
                for (int i = 0; i < dr.Table.Columns.Count; i++)
                {
                    PropertyInfo propertyInfo = model.GetType().GetProperty(dr.Table.Columns[i].ColumnName);
                    if (propertyInfo != null && dr[i] != DBNull.Value)
                        propertyInfo.SetValue(model, dr[i], null);
                }

                modelList.Add(model);
            }
            return modelList;
        }



        /// <summary>
        /// datatable轉換為List<T>集合
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="table"></param>
        /// <returns></returns>
        public static List<T> DataTableToList<T>(DataTable table)
        {
            var list = new List<T>();
            foreach (DataRow item in table.Rows)
            {
                list.Add(DataRowToModel<T>(item));
            }
            return list;
        }
        #endregion




        #region DataRow=>Model
        /// <summary>  
        /// 填充對象：用DataRow填充實體類
        /// </summary>  
        public T FillModelByDataRow(DataRow dr)
        {
            if (dr == null)
            {
                return default(T);
            }

            //T model = (T)Activator.CreateInstance(typeof(T));  
            T model = new T();

            for (int i = 0; i < dr.Table.Columns.Count; i++)
            {
                PropertyInfo propertyInfo = model.GetType().GetProperty(dr.Table.Columns[i].ColumnName);
                if (propertyInfo != null && dr[i] != DBNull.Value)
                    propertyInfo.SetValue(model, dr[i], null);
            }
            return model;
        }


        public static T DataRowToModel<T>(DataRow row)
        {
            T model;
            var type = typeof(T);
            var modelType = GetModelType(type);
            switch (modelType)
            {
                //值類型
                case ModelType.Struct:
                    {
                        model = default(T);
                        if (row[0] != null)
                            model = (T)row[0];
                    }
                    break;
                //值類型
                case ModelType.Enum:
                    {
                        model = default(T);
                        if (row[0] != null)
                        {
                            var fiType = row[0].GetType();
                            if (fiType == typeof(int))
                            {
                                model = (T)row[0];
                            }
                            else if (fiType == typeof(string))
                            {
                                model = (T)Enum.Parse(typeof(T), row[0].ToString());
                            }
                        }
                    }
                    break;
                //引用類型 c#對string也當做值類型處理
                case ModelType.String:
                    {
                        model = default(T);
                        if (row[0] != null)
                            model = (T)row[0];
                    }
                    break;
                //引用類型 直接返回第一行第一列的值
                case ModelType.Object:
                    {
                        model = default(T);
                        if (row[0] != null)
                            model = (T)row[0];
                    }
                    break;
                //引用類型
                case ModelType.Else:
                    {
                        //引用類型 必須對泛型實例化
                        model = Activator.CreateInstance<T>();
                        //獲取model中的屬性
                        var modelPropertyInfos = type.GetProperties();
                        //遍歷model每一個屬性並賦值DataRow對應的列
                        foreach (var pi in modelPropertyInfos)
                        {
                            //獲取屬性名稱
                            var name = pi.Name;
                            if (!row.Table.Columns.Contains(name) || row[name] == null || row[name] == DBNull.Value) continue;
                            var piType = GetModelType(pi.PropertyType);
                            switch (piType)
                            {
                                case ModelType.Struct:
                                    {
                                        object value;
                                        if (!pi.PropertyType.Name.ToLower().Contains("nullable"))
                                            value = Convert.ChangeType(row[name], pi.PropertyType);
                                        else
                                            value = new NullableConverter(pi.PropertyType).ConvertFromString(row[name].ToString());
                                        pi.SetValue(model, value, null);
                                    }
                                    break;

                                case ModelType.Enum:
                                    {
                                        var fiType = row[0].GetType();
                                        if (fiType == typeof(int))
                                        {
                                            pi.SetValue(model, row[name], null);
                                        }
                                        else if (fiType == typeof(string))
                                        {
                                            var value = (T)Enum.Parse(typeof(T), row[name].ToString());
                                            if (value != null)
                                                pi.SetValue(model, value, null);
                                        }
                                    }
                                    break;

                                case ModelType.String:
                                    {
                                        var value = Convert.ChangeType(row[name], pi.PropertyType);
                                        pi.SetValue(model, value, null);
                                    }
                                    break;

                                case ModelType.Object:
                                    {
                                        pi.SetValue(model, row[name], null);
                                    }
                                    break;

                                case ModelType.Else:
                                    throw new Exception("不支持該類型轉換");
                                default:
                                    throw new Exception("未知類型");
                            }
                        }
                    }
                    break;

                default:
                    model = default(T);
                    break;
            }
            return model;
        }

        #endregion
    }
    #endregion

    #region SqlHelper
    public class SqlHelper
    {
        /// <summary>
        /// 從配置文件中讀取數據庫連接字符串
        /// </summary>
        public static string ConnectionString = ConfigurationManager.ConnectionStrings["constr"].ConnectionString;

        private static SqlConnection conn;

        #region 公共靜態方法

        /// <summary>
        /// 填充DataTable
        /// </summary>
        /// <param name="spname">存儲過程名</param>
        /// <param name="sqlParams">參數集</param>
        /// <returns>結果datatable</returns>
        public static DataTable FillDataTable(string spname, params SqlParameter[] sqlParams)
        {
            conn = new SqlConnection(ConnectionString);
            using (SqlDataAdapter adapter = new SqlDataAdapter(spname, conn))
            {
                adapter.SelectCommand.CommandType = CommandType.StoredProcedure;
                if (sqlParams != null && sqlParams.Length > 0)
                {
                    for (int i = 0; i < sqlParams.Length; i++)
                    {
                        adapter.SelectCommand.Parameters.Add(sqlParams[i]);
                    }
                }
                DataTable table = new DataTable();
                adapter.Fill(table);
                return table;
            }
        }

        /// <summary>
        /// 執行一條SQL的select語句，用返回的結果填充DataTable
        /// </summary>
        /// <param name="sql">要執行的SQL語句</param>
        /// <param name="oParams">SQL語句中的參數</param>
        /// <returns>已填充數據的DataTable</returns>
        public static DataTable FillSqlDataTable(string sql, params SqlParameter[] oParams)
        {
            using (conn = new SqlConnection(ConnectionString))
            {
                SqlDataAdapter adapter = new SqlDataAdapter(sql, conn);
                if (oParams != null && oParams.Length > 0)
                {
                    foreach (SqlParameter prm in oParams)
                    {
                        adapter.SelectCommand.Parameters.Add(prm);
                    }
                }
                DataTable table = new DataTable();
                adapter.Fill(table);
                return table;
            }
        }

        /// <summary>
        /// 執行一條存儲過程，返回SqlDataReader
        /// </summary>
        /// <param name="spname">存儲過程名稱</param>
        /// <param name="sqlParams">存儲過程參數集合</param>
        /// <returns>SqlDataReader</returns>
        public static SqlDataReader ExecuteReader(string spname, params SqlParameter[] sqlParams)
        {
            return ExecuteReader(CommandType.StoredProcedure, spname, sqlParams);
        }

        /// <summary>
        /// 執行一條存儲過程或SQL語句，返回SqlDataReader
        /// </summary>
        /// <param name="cmdText">SQL語句或存儲過程名稱</param>
        /// <param name="sqlParams">SQL參數集合</param>
        /// <returns>SqlDataReader</returns>
        public static SqlDataReader ExecuteReader(CommandType cmdType, string cmdText, params SqlParameter[] sqlParams)
        {
            conn = new SqlConnection(ConnectionString);
            using (SqlCommand cmd = new SqlCommand(cmdText, conn))
            {
                cmd.CommandType = cmdType;
                if (sqlParams != null && sqlParams.Length > 0)
                {
                    for (int i = 0; i < sqlParams.Length; i++)
                    {
                        cmd.Parameters.Add(sqlParams[i]);
                    }
                }
                try
                {
                    cmd.Connection.Open();
                    return cmd.ExecuteReader(CommandBehavior.CloseConnection);
                }
                catch
                {
                    cmd.Connection.Close();
                    throw;
                }
            }
        }

        /// <summary>
        /// 執行存儲過程
        /// </summary>
        /// <param name="spname">存儲過程名稱</param>
        /// <param name="sqlParams">存儲過程參數集合</param>
        /// <returns>受影響的記錄行數</returns>
        public static int ExecuteNonQuery(string spname, params SqlParameter[] sqlParams)
        {
            return ExecuteNonQuery(CommandType.StoredProcedure, spname, sqlParams);
        }

        /// <summary>
        /// 執行一條SQL語句，獲取受SQL語句中delete、update和insert語句影響的行數
        /// </summary>
        /// <param name="sql">要執行的SQL語句</param>
        /// <param name="oParams">SQL語句中的參數</param>
        /// <returns>受SQL語句中delete、update和insert語句影響的行數</returns>
        public static int ExecuteSqlNonQuery(string sql, params SqlParameter[] oParams)
        {
            using (conn = new SqlConnection(ConnectionString))
            {
                SqlCommand cmd = new SqlCommand(sql, conn);
                conn.Open();
                if (oParams != null && oParams.Length > 0)
                {
                    foreach (SqlParameter prm in oParams)
                    {
                        cmd.Parameters.Add(prm);
                    }
                }
                int reslt = cmd.ExecuteNonQuery();
                conn.Close();
                return reslt;
            }
        }

        /// <summary>
        /// 執行SQL語句或存儲過程
        /// </summary>
        /// <param name="cmdType">執行類型：SQL語句或存儲過程</param>
        /// <param name="cmdText">要執行的SQL語句或存儲過程名</param>
        /// <param name="sqlParams">SQL參數集合</param>
        /// <returns>受影響的記錄行數</returns>
        public static int ExecuteNonQuery(CommandType cmdType, string cmdText, params SqlParameter[] sqlParams)
        {
            conn = new SqlConnection(ConnectionString);

            using (SqlCommand cmd = new SqlCommand(cmdText, conn))
            {
                cmd.CommandType = cmdType;
                if (sqlParams != null && sqlParams.Length > 0)
                {
                    for (int i = 0; i < sqlParams.Length; i++)
                    {
                        cmd.Parameters.Add(sqlParams[i]);
                    }
                }
                conn.Open();
                int j = cmd.ExecuteNonQuery();
                conn.Close();
                return j;
            }
        }

        /// <summary>
        /// 執行SQL語句或存儲過程返回第一行第一列的數據
        /// </summary>
        /// <param name="cmdType">執行類型：SQL語句或存儲過程</param>
        /// <param name="sqlParams">參數集</param>
        /// <param name="cmdText">執行語句</param>
        /// <returns>返回第一行第一列的數據</returns>
        public static object ExecuteScalar(CommandType cmdType, string cmdText, params SqlParameter[] sqlParams)
        {
            conn = new SqlConnection(ConnectionString);
            using (SqlCommand cmd = new SqlCommand(cmdText, conn))
            {
                cmd.CommandType = cmdType;
                if (sqlParams != null && sqlParams.Length > 0)
                {
                    for (int i = 0; i < sqlParams.Length; i++)
                    {
                        cmd.Parameters.Add(sqlParams[i]);
                    }
                }
                conn.Open();
                object obj = null;
                try
                {
                    obj = cmd.ExecuteScalar();
                }
                catch
                {
                    conn.Close();
                    conn.Open();
                    obj = cmd.ExecuteScalar();
                }
                conn.Close();
                return obj;
            }
        }

        /// <summary>
        /// 執行存儲過程，填充DataRow，若無數據則返回null
        /// </summary>
        /// <param name="spname">執行語句</param>
        /// <param name="sqlParams">參數集</param>
        /// <returns>返回DataRow</returns>
        public static DataRow FillDataRow(string spname, params SqlParameter[] sqlParams)
        {
            DataTable table = FillDataTable(spname, sqlParams);
            if (table.Rows.Count > 0)
                return table.Rows[0];
            return null;
        }

        /// <summary>
        /// 向數據庫中插入或更新數據時，設置存儲過程參數
        /// </summary>
        /// <param name="pName">存儲過程參數名</param>
        /// <param name="pValue">參數值</param>
        /// <returns>返回SqlParameter</returns>
        public static SqlParameter SetParam(string pName, object pValue)
        {
            //如果pValue為null，則直接返回 2004-12-6
            if (pValue == null)
                return new SqlParameter(pName, pValue);
            switch (Type.GetTypeCode(pValue.GetType()))
            {
                case TypeCode.String:
                    string tempStr = (string)pValue;
                    if (tempStr.Equals(null) || tempStr.Trim().Length.Equals(0))
                    {
                        return new SqlParameter(pName, DBNull.Value);
                    }
                    return new SqlParameter(pName, tempStr);

                case TypeCode.DateTime:
                    DateTime tempdt = (DateTime)pValue;
                    if (tempdt.Equals(DateTime.MinValue))
                    {
                        return new SqlParameter(pName, DBNull.Value);
                    }
                    return new SqlParameter(pName, tempdt);

                default:
                    return new SqlParameter(pName, pValue);
            }
        }

        /// <summary>
        /// 獲取SqlDataReader中指定字符串字段的值
        /// </summary>
        /// <param name="reader">包含數據的SqlDataReader</param>
        /// <param name="fieldName">字段名</param>
        /// <returns>字段值，若字段為空則返回空字符串</returns>
        public static string GetStringFieldValue(SqlDataReader reader, string fieldName)
        {
            if (Convert.IsDBNull(reader[fieldName]))
            {
                return String.Empty;
            }
            return reader[fieldName].ToString();
        }

        /// <summary>
        /// 獲取SqlDataReader中指定Int字段的值，若該字段為空則返回指定的替換值
        /// </summary>
        /// <param name="reader">包含數據的SqlDataReader</param>
        /// <param name="fieldName">字段名</param>
        /// <param name="replaceValue">要替換值為空的字段的值</param>
        /// <returns>字段值，若該字段為空則返回replaceValue</returns>
        public static int GetIntFieldValue(SqlDataReader reader, string fieldName, int replaceValue)
        {
            if (Convert.IsDBNull(reader[fieldName]))
            {
                return replaceValue;
            }
            object obj = reader[fieldName];
            return Convert.ToInt32(reader[fieldName]);
        }

        /// <summary>
        /// 獲取SqlDataReader中指定Int字段的值
        /// </summary>
        /// <param name="reader">包含數據的SqlDataReader</param>
        /// <param name="fieldName">字段名</param>
        /// <returns>字段值，若該字段為空則返回0</returns>
        public static int GetIntFieldValue(SqlDataReader reader, string fieldName)
        {
            return GetIntFieldValue(reader, fieldName, 0);
        }

        /// <summary>
        /// 獲取SqlDataReader中指定byte字段（SQL Server中為tinyint類型）的值
        /// </summary>
        /// <param name="reader">包含數據的SqlDataReader</param>
        /// <param name="fieldName">要取值的字段名</param>
        /// <returns>返回byte類型結果</returns>
        public static byte GetByteFieldValue(SqlDataReader reader, string fieldName)
        {
            if (Convert.IsDBNull(reader[fieldName]))
                return 0;
            return (byte)reader[fieldName];
        }

        /// <summary>
        /// 獲取SqlDataReader中指定decimal字段的值，若該字段為空則返回指定的替換值
        /// </summary>
        /// <param name="reader">包含數據的SqlDataReader</param>
        /// <param name="fieldName">要取值的字段名</param>
        /// <param name="replaceValue">要替換值為空的字段的值</param>
        /// <returns>返回double類型結果</returns>
        public static Double GetDoubleFieldValue(SqlDataReader reader, string fieldName, Double replaceValue)
        {
            if (Convert.IsDBNull(reader[fieldName]))
                return replaceValue;
            return (Double)reader[fieldName];
        }

        /// <summary>
        /// 獲取SqlDataReader中指定Int字段的值，若該字段為空則返回0
        /// </summary>
        /// <param name="reader">包含數據的SqlDataReader</param>
        /// <param name="fieldName">要取值的字段名</param>
        /// <returns>返回double類型結果</returns>
        public static Double GetDoubleFieldValue(SqlDataReader reader, string fieldName)
        {
            return GetDoubleFieldValue(reader, fieldName, 0);
        }

        /// <summary>
        /// 獲取SqlDataReader中指定float字段的值，若該字段為空則返回0
        /// </summary>
        /// <param name="reader">包含數據的SqlDataReader</param>
        /// <param name="fieldName">要取值的字段名</param>
        /// <returns>返回double類型結果</returns>
        public static float GetFloatFieldValue(SqlDataReader reader, string fieldName)
        {
            return GetFloatFieldValue(reader, fieldName, 0);
        }

        /// <summary>
        /// 獲取SqlDataReader中指定decimal字段的值，若該字段為空則返回指定的替換值
        /// </summary>
        /// <param name="reader">包含數據的SqlDataReader</param>
        /// <param name="fieldName">要取值的字段名</param>
        /// <param name="replaceValue">要替換值為空的字段的值</param>
        /// <returns>返回double類型結果</returns>
        public static float GetFloatFieldValue(SqlDataReader reader, string fieldName, float replaceValue)
        {
            if (Convert.IsDBNull(reader[fieldName]))
                return replaceValue;
            return float.Parse(reader[fieldName].ToString());
        }

        /// <summary>
        /// 獲取SqlDataReader中指定Int字段的值，若該字段為空則返回DateTime的最小值
        /// </summary>
        /// <param name="reader">包含數據的SqlDataReader</param>
        /// <param name="fieldName">要取值的字段名</param>
        /// <returns>返回DateTime類型結果</returns>
        public static DateTime GetDateTimeFieldValue(SqlDataReader reader, string fieldName)
        {
            if (Convert.IsDBNull(reader[fieldName]))
                return DateTime.MinValue;
            return (DateTime)reader[fieldName];
        }

        #region 僅用於綜合查詢

        /// <summary>
        /// 執行查詢語句，返回DataSet(zhaibl 09-11-04添加此方法)
        /// </summary>
        /// <param name="SQLString">查詢語句</param>
        /// <returns>DataSet</returns>
        public static DataSet Query(string SQLString)
        {
            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;
            }
        }

        /// <summary>
        /// 執行一條計算查詢結果語句，返回查詢結果（object）。
        /// </summary>
        /// <param name="SQLString">計算查詢結果語句</param>
        /// <returns>查詢結果（object）</returns>
        public static object GetSingle(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>
        /// 填充數據集(執行帶參的sql),返回DataSet
        /// </summary>
        /// <param name="sql">sql語句</param>
        /// <param name="oParams">參數集</param>
        /// <returns>datasat</returns>
        public static DataSet FillDataSet(string sql, params SqlParameter[] oParams)
        {
            using (SqlConnection conn = new SqlConnection(ConnectionString))
            {
                SqlDataAdapter adapter = new SqlDataAdapter(sql, conn);
                if (oParams != null && oParams.Length > 0)
                {
                    foreach (SqlParameter prm in oParams)
                    {
                        adapter.SelectCommand.Parameters.Add(prm);
                    }
                }
                DataSet ds = new DataSet();
                adapter.Fill(ds);
                return ds;
            }
        }

        /// <summary>
        /// 執行一條SQL語句，獲取受SQL語句中delete、update和insert語句影響的行數
        /// </summary>
        /// <param name="sql">要執行的SQL語句</param>
        /// <param name="oParams">SQL語句中的參數</param>
        /// <returns>受SQL語句中delete、update和insert語句影響的行數</returns>
        public static int ExecuteSqlNonQuery1(string sql, params SqlParameter[] oParams)
        {
            int reslt = 0;
            try
            {
                using (conn = new SqlConnection(ConnectionString))
                {
                    SqlCommand cmd = new SqlCommand(sql, conn);
                    conn.Open();
                    cmd.CommandType = CommandType.StoredProcedure;
                    cmd.Parameters.AddRange(oParams);
                    reslt = cmd.ExecuteNonQuery();
                    conn.Close();
                }
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
            return reslt;
        }

        /// <summary>
        /// 獲取查詢結果
        /// </summary>
        /// <param name="sql">要執行的SQL語句</param>
        /// <returns>DataTable</returns>
        public static DataTable GetQueryResult(string sql)
        {
            DataTable tbl = new DataTable();
            conn = new SqlConnection(ConnectionString);
            using (SqlDataAdapter adapter = new SqlDataAdapter(sql, conn))
            {
                adapter.Fill(tbl);
            }
            conn.Close();
            return tbl;
        }

        #endregion 僅用於綜合查詢

        #endregion 公共靜態方法

        #region 事務--Bao--2017-08-17

        /// <summary>
        /// 創建一個事務
        /// </summary>
        /// <returns></returns>
        public static SqlTransaction CreateTrans()
        {
            conn = new SqlConnection(ConnectionString);
            conn.Open();
            return conn.BeginTransaction();
        }

        /// <summary>
        /// 關閉並釋放與事務有關的資源
        /// </summary>
        /// <param name="trans"></param>
        public static void CloseTrans(SqlTransaction trans)
        {
            if (trans == null) return;

            trans.Dispose();

            if (conn == null || conn.State != ConnectionState.Open) return;
            conn.Close();
            conn.Dispose();
        }

        /// <summary>
        /// 執行一條不返回結果的SqlCommand，通過一個已經存在的數據庫事物處理
        /// 使用參數數組提供參數
        /// </summary>
        /// <param name="trans">一個存在的 sql 事物處理</param>
        /// <param name="commandType">SqlCommand命令類型 (存儲過程， T-SQL語句， 等等。)</param>
        /// <param name="commandText">存儲過程的名字或者 T-SQL 語句</param>
        /// <param name="sqlParams">以數組形式提供SqlCommand命令中用到的參數列表</param>
        /// <returns>返回一個數值表示此SqlCommand命令執行后影響的行數</returns>
        public static int ExecuteNonQuery(SqlTransaction trans, CommandType cmdType, string cmdText, params SqlParameter[] sqlParams)
        {
            if (trans == null) return ExecuteNonQuery(cmdType, cmdText, sqlParams);

            using (SqlCommand cmd = new SqlCommand())
            {
                PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, sqlParams);
                int val = cmd.ExecuteNonQuery();
                cmd.Parameters.Clear();
                return val;
            }
        }

        /// <summary>
        /// 執行SQL語句或存儲過程返回第一行第一列的數據
        /// </summary>
        /// <param name="trans">一個存在的 sql 事物處理</param>
        /// <param name="cmdType">執行類型：SQL語句或存儲過程</param>
        /// <param name="sqlParams">參數集</param>
        /// <param name="cmdText">執行語句</param>
        /// <returns>返回第一行第一列的數據</returns>
        public static object ExecuteScalar(SqlTransaction trans, CommandType cmdType, string cmdText, params SqlParameter[] sqlParams)
        {
            if (trans == null) return ExecuteScalar(cmdType, cmdText, sqlParams);

            using (SqlCommand cmd = new SqlCommand())
            {
                PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, sqlParams);
                object val = cmd.ExecuteScalar();
                cmd.Parameters.Clear();
                return val;
            }
        }

        /// <summary>
        /// 為執行命令准備參數
        /// </summary>
        /// <param name="cmd">SqlCommand 命令</param>
        /// <param name="conn">已經存在的數據庫連接</param>
        /// <param name="trans">數據庫事物處理</param>
        /// <param name="cmdType">SqlCommand命令類型 (存儲過程， T-SQL語句， 等等。)</param>
        /// <param name="cmdText">Command text，T-SQL語句 例如 Select * from Products</param>
        /// <param name="cmdParms">返回帶參數的命令</param>
        private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, CommandType cmdType, 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 = cmdType;

            if (cmdParms != null)
            {
                foreach (SqlParameter parm in cmdParms)
                    cmd.Parameters.Add(parm);
            }
        }

        #endregion 事務--Bao--2017-08-17

        public static void LogInfo(string msg)
        {
            string FilePath = AppDomain.CurrentDomain.SetupInformation.ApplicationBase + "log\\";
            if (!System.IO.Directory.Exists(FilePath))
            {
                System.IO.Directory.CreateDirectory(FilePath);
            }
            try
            {
                string fileName = FilePath + DateTime.Now.ToString("yyyyMMdd") + ".log";
                var logStreamWriter = new System.IO.StreamWriter(fileName, true, Encoding.GetEncoding("gb2312"));


                logStreamWriter.WriteLine(msg);
                logStreamWriter.Close();
            }
            catch
            { }
        }

        #region 標准MD5加密
        /// <summary>
        /// MD5加密字符串
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string Md5String(string str)
        {
            string pwd = String.Empty;
            MD5 md5 = MD5.Create();
            // 編碼UTF8/Unicode　
            byte[] s = md5.ComputeHash(Encoding.UTF8.GetBytes(str));
            // 轉換成字符串
            for (int i = 0; i < s.Length; i++)
            {
                //格式后的字符是小寫的字母
                //如果使用大寫（X）則格式后的字符是大寫字符
                pwd = pwd + s[i].ToString("x2");
            }
            return pwd;
        }
        #endregion

        #region 分頁

        /// <summary>
        /// 獲取分頁數據
        /// </summary>
        /// <param name="tableName">表名</param>
        /// <param name="primaryKey">主鍵字段名</param>
        /// <param name="pageIndex">頁碼</param>
        /// <param name="pageSize">頁尺寸</param>
        /// <param name="isReCount">返回記錄總數, 非 0 值則返回</param>
        /// <param name="orderType">設置排序類型, 非 0 值則降序</param>
        /// <param name="where">查詢條件 (注意: 不要加 where)</param>
        /// <param name="recount">返回記錄總數</param>
        /// <param name="pageCount">返回總頁數</param>
        /// <returns></returns>
        public static DataTable GetPage(string tableName, string primaryKey, int pageIndex, int pageSize, int isReCount, int orderType, string where, out int recount, out int pageCount)
        {
            string procName = "SP_Page";
            SqlParameter[] paras = new SqlParameter[]{
                new SqlParameter("@Recount",SqlDbType.Int),
                new SqlParameter("@PageCount",SqlDbType.Int),
                new SqlParameter("@tblName",tableName),
                new SqlParameter("@fldName",primaryKey),
                new SqlParameter("@PageSize",pageSize),
                new SqlParameter("@PageIndex",pageIndex),
                new SqlParameter("@IsReCount",isReCount),
                new SqlParameter("@OrderType",orderType),
                new SqlParameter("@strWhere",where)
            };

            paras[0].Direction = ParameterDirection.Output;
            paras[1].Direction = ParameterDirection.Output;

            DataTable dt = SqlHelper.FillDataTable(procName, paras);

            recount = int.Parse(paras[0].Value.ToString());
            pageCount = int.Parse(paras[1].Value.ToString());

            return dt;
        }






        public static string newShowPageNavNew(int pageCurrent, int totalCount, int pageSize = 5, string methodName = "getlist")
        {
            var totalPage = Math.Max((totalCount + pageSize - 1) / pageSize, 1);
            //if (totalPage >= 1)
            //{
            //要輸出的超鏈接字符串
            var pageNav = new StringBuilder();
            //左邊代碼
            //無數據
            if (totalCount == 0)
            {
                pageNav.AppendFormat("<div class='col-sm-4'><div class='dataTables_info' id='editable_info' role='alert' aria-live='polite' aria-relevant='all'>顯示 0 項，共 0 項</div></div>");
            }
            else
            {
                //最后一頁文件數量
                if (pageCurrent == totalPage)
                {
                    pageNav.AppendFormat("<div class='col-sm-4'><div class='dataTables_info' id='editable_info' role='alert' aria-live='polite' aria-relevant='all'>顯示 " + ((pageCurrent - 1) * pageSize + 1) + " 到 " + totalCount + " 項，共 " + totalCount + " 項</div></div>");
                }
                else
                {
                    pageNav.AppendFormat("<div class='col-sm-4'><div class='dataTables_info' id='editable_info' role='alert' aria-live='polite' aria-relevant='all'>顯示 " + ((pageCurrent - 1) * pageSize + 1) + " 到 " + (pageCurrent * pageSize) + " 項，共 " + totalCount + " 項</div></div>");
                }
            }

            //右邊代碼
            pageNav.AppendFormat("<div class='col-sm-8'><div class='dataTables_paginate paging_simple_numbers' id='editable_paginate'><ul class='pagination'>");

            //如果當前是第一頁，則“上一頁”不可點
            if (pageCurrent == 1)
            {
                pageNav.AppendFormat("<li class='paginate_button previous disabled' aria-controls='editable' tabindex='0' id='editable_previous'><a href='javascript:void(0)'>上一頁</a></li>");
            }
            else
            {
                pageNav.AppendFormat("<li class='paginate_button previous' aria-controls='editable' tabindex='0' id='editable_previous'><a href='javascript:void(0)' onclick='" + methodName + "({0},{1})'>{2}</a></li>", pageCurrent - 1, pageSize, "上一頁");
            }

            //中間頁碼 
            if (pageCurrent <= 3)
            {
                for (int i = 1; i < 8; i++)
                {
                    if (i <= totalPage)
                    {
                        if (pageCurrent == i) //當前頁處理
                        {
                            pageNav.AppendFormat("<li class='paginate_button active' aria-controls='editable' tabindex='0'><a href='javascript:void(0)'>{0}</a></li>", pageCurrent);
                        }
                        else //一般頁處理
                        {
                            pageNav.AppendFormat("<li class='paginate_button previous' aria-controls='editable' tabindex='0' id='editable_previous'><a href='javascript:void(0)' onclick='" + methodName + "({0},{1})'>{2}</a></li>", i, pageSize, i);
                        }
                    }
                }
            }
            else if (pageCurrent > 3 && pageCurrent < totalPage - 3)
            {
                int current = 4;
                for (int i = 1; i < 8; i++)
                {
                    if ((pageCurrent + i - current) >= 1 && (pageCurrent + i - current) <= totalPage)
                    {
                        if (current == i) //當前頁處理
                        {
                            pageNav.AppendFormat("<li class='paginate_button active' aria-controls='editable' tabindex='0'><a href='javascript:void(0)'>{0}</a></li>", pageCurrent);
                        }
                        else //一般頁處理
                        {
                            pageNav.AppendFormat("<li class='paginate_button previous' aria-controls='editable' tabindex='0' id='editable_previous'><a href='javascript:void(0)' onclick='" + methodName + "({0},{1})'>{2}</a></li>", pageCurrent + i - current, pageSize, pageCurrent + i - current);
                        }
                    }
                }

            }
            else
            {
                for (int i = totalPage - 6; i <= totalPage; i++)
                {
                    if (i <= totalPage && i > 0)
                    {
                        if (pageCurrent == i) //當前頁處理
                        {
                            pageNav.AppendFormat("<li class='paginate_button active' aria-controls='editable' tabindex='0'><a href='javascript:void(0)'>{0}</a></li>", pageCurrent);
                        }
                        else //一般頁處理
                        {
                            pageNav.AppendFormat("<li class='paginate_button previous' aria-controls='editable' tabindex='0' id='editable_previous'><a href='javascript:void(0)' onclick='" + methodName + "({0},{1})'>{2}</a></li>", i, pageSize, i);
                        }
                    }
                }
            }

            //如果當前是最后一頁，則“下一頁”不可點
            if (pageCurrent == totalPage)
            {
                pageNav.AppendFormat("<li class='paginate_button next disabled' aria-controls='editable' tabindex='0' id='editable_next'><a href='javascript:void(0)'>下一頁</a></li>");
            }
            else
            {
                pageNav.AppendFormat("<li class='paginate_button next' aria-controls='editable' tabindex='0' id='editable_next'><a href='javascript:void(0)' onclick='" + methodName + "({0},{1})'>{2}</a></li>", pageCurrent + 1, pageSize, "下一頁");
            }
            pageNav.AppendFormat("</ul></div></div>");
            return pageNav.ToString();
            //}
            //else
            //{
            //    return string.Empty;
            //}
        }
        #endregion
    }
    #endregion
}