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 = ;
        #region DBNull类型转换
        public static long ToInt64(object value)
        {
            return (Convert.IsDBNull(value)) ?  : Convert.ToInt64(value);
        }

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

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

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

        public static decimal ToDecimal(object value)
        {
            return (Convert.IsDBNull(value)) ?  : 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, , toEncryptArray.Length);

            var hex = BitConverter.ToString(resultArray, ).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 / ];
            for (var x = ; x < toEncryptArray.Length; x++)
            {
                var i = Convert.ToInt32(str.Substring(x * , ), );
                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, , toEncryptArray.Length);

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

        #region 获取时间戳，取随机数
        /// <summary>
        /// 获取时间戳
        /// </summary>
        /// <returns></returns>
        public static long GetTimeStamp()
        {
            TimeSpan ts = DateTime.UtcNow - new DateTime(, , , , , , );
            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(, , )));
            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(, , ));
            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"), )));
        }

        /// <summary>
        /// Stream流转化为字符串
        /// </summary>
        /// <returns></returns>
        public static string StreamToString(Stream stream)
        {
            if (stream == null || stream.Length == )
            {
                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 = ; 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 = ;
            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, , 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 = ;
            foreach (var item in dic)
            {
                if (i > )
                    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, , 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, , 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, , 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, , 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 = ;

                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 = ; i < bytHash.Length; i++)
            {
                sTemp += bytHash[i].ToString("x").PadLeft(, '');
            }
            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)), , );
            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[] == null || ds.Tables[].Rows.Count == )
            {
                return null;
            }
            else
            {
                return FillModelByDataTable(ds.Tables[]);
            }
        }
        #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 == )
            {
                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 = ; 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 = ; 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[] != null)
                            model = (T)row[];
                    }
                    break;
                //值类型
                case ModelType.Enum:
                    {
                        model = default(T);
                        if (row[] != null)
                        {
                            var fiType = row[].GetType();
                            if (fiType == typeof(int))
                            {
                                model = (T)row[];
                            }
                            else if (fiType == typeof(string))
                            {
                                model = (T)Enum.Parse(typeof(T), row[].ToString());
                            }
                        }
                    }
                    break;
                //引用类型 c#对string也当做值类型处理
                case ModelType.String:
                    {
                        model = default(T);
                        if (row[] != null)
                            model = (T)row[];
                    }
                    break;
                //引用类型 直接返回第一行第一列的值
                case ModelType.Object:
                    {
                        model = default(T);
                        if (row[] != null)
                            model = (T)row[];
                    }
                    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[].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 > )
                {
                    for (int i = ; 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 > )
                {
                    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 > )
                {
                    for (int i = ; 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 > )
                {
                    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 > )
                {
                    for (int i = ; 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 > )
                {
                    for (int i = ; 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 > )
                return table.Rows[];
            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())
                    {
                        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, );
        }

        /// <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 ;
            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, );
        }

        /// <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, );
        }

        /// <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 > )
                {
                    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 = ;
            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 = ; 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[].Direction = ParameterDirection.Output;
            paras[].Direction = ParameterDirection.Output;

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

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

            return dt;
        }

        public static string newShowPageNavNew(int pageCurrent, int totalCount, int pageSize = , string methodName = "getlist")
        {
            var totalPage = Math.Max((totalCount + pageSize - ) / pageSize, );
            //if (totalPage >= 1)
            //{
            //要输出的超链接字符串
            var pageNav = new StringBuilder();
            //左边代码
            //无数据
            if (totalCount == )
            {
                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 - ) * pageSize + ) + " 到 " + 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 - ) * pageSize + ) + " 到 " + (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 == )
            {
                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 - , pageSize, "上一页");
            }

            //中间页码
            if (pageCurrent <= )
            {
                for (int i = ; i < ; 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 >  && pageCurrent < totalPage - )
            {
                int current = ;
                for (int i = ; i < ; i++)
                {
                    if ((pageCurrent + i - current) >=  && (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 - ; i <= totalPage; i++)
                {
                    if (i <= totalPage && i > )
                    {
                        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 + , pageSize, "下一页");
            }
            pageNav.AppendFormat("</ul></div></div>");
            return pageNav.ToString();
            //}
            //else
            //{
            //    return string.Empty;
            //}
        }
        #endregion
    }
    #endregion
}