C#做网站公共方法(20160521)

namespace Swt.Web.Public
{
    /// <summary>
    /// 单例模式基类 by LH
    /// </summary>
    public class swtSingleTon<T> where T : class,new()
    {
        private static volatile T _instance;
        private static readonly object _lock = new object();

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public static T Instance()
        {
            if (_instance == null)
            {
                lock (_lock)
                {
                    if (_instance == null)
                    {
                        _instance = new T();
                    }
                }
            }
            return _instance;
        }
    }
}

using System;
using Newtonsoft.Json;

namespace Swt.Web.Public
{
    /// <summary>
    /// json 转 实体类 by LH
    /// </summary>
    public class swtJson2Obj<T>
    {
        /// <summary>
        /// 转换
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        public static T Convert(string json)
        {
            T obj = JsonConvert.DeserializeObject<T>(json);
            return obj;
        }
    }
}

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Drawing.Drawing2D;
using System.IO;
using System.Web;
using System.Configuration;
using System.Text.RegularExpressions;
using System.Web.Caching;
using System.Collections;
using Microsoft.JScript;
using System.Data;
using System.Text;
using Newtonsoft.Json;

namespace Swt.Web.Public
{
    /// <summary>
    /// 自定义公共类用于MVC使用 by LH
    /// </summary>
    public class swtWebPageHelper : swtSingleTon<swtWebPageHelper>
    {
        #region--------------------------------获取路由信息--------------------------------
        /// <summary>
        /// 获取控制器 获取失败为 空字符
        /// </summary>
        /// <returns></returns>
        public string GetRouteController()
        {
            try
            {
                return HttpContext.Current.Request.RequestContext.RouteData.Values["controller"].ToString();
            }
            catch (Exception e)
            {
                string result = e.Message;
                result = "";
                return result;
            }
        }

        /// <summary>
        /// 获取控制器 下面的 action 获取失败为 空字符
        /// </summary>
        /// <returns></returns>
        public string GetRouteAction()
        {
            try
            {
                return HttpContext.Current.Request.RequestContext.RouteData.Values["action"].ToString();
            }
            catch (Exception e)
            {
                string result = e.Message;
                result = "";
                return result;
            }
        }

        /// <summary>
        /// 获取url中的id,即FormId 获取失败为 空字符
        /// </summary>
        /// <returns></returns>
        public string GetRouteId()
        {
            try
            {
                return HttpContext.Current.Request.RequestContext.RouteData.Values["id"].ToString();
            }
            catch (Exception e)
            {
                string result = e.Message;
                result = "";
                return result;
            }
        }

        /// <summary>
        /// 获取FormId,Ajax请求时的FormId需要特殊处理
        /// </summary>
        /// <returns>FormId</returns>
        public string GetFormId()
        {
            string url = "";
            if (HttpContext.Current.Request.UrlReferrer != null)//ajax请求时的页面url
            {
                url = HttpContext.Current.Request.UrlReferrer.AbsoluteUri.ToString();//获取实际的URL信息
            }
            else//实际页面请求时的页面url
            {
                url = HttpContext.Current.Request.RawUrl.ToString();
            }

            string param = "";//查询参数 
            if (url.Contains("?"))
            {
                param = url.Substring(url.IndexOf("?"));
            }

            string PageUrl = url;//页面url
            if (param != "")
            {
                PageUrl = url.Replace(param, "");
            }

            string FormId = "";//截取FormId
            string[] PageUrlArr = PageUrl.Split('/');
            int PageUrlArrLen = PageUrlArr.Length;
            if (PageUrlArrLen > 5)
            {
                FormId = PageUrlArr[PageUrlArrLen - 1];//默认取最后一部分;
                if (FormId == "")
                {
                    FormId = PageUrlArr[PageUrlArrLen - 2];
                }
            }
            FormId = FormId.Replace("#", "");// a 标签点击时部分浏览器会在url附加上 # 字符,导致最终得到的 FormId不正确,因此需要过滤掉
            return FormId;
        }
        #endregion

        #region--------------------------------生成 对应sql--------------------------------
        /// <summary>
        /// 生成分页语句(sql,行数,页码),如果使用了 easyui 的表格控件,只需要前台配置好列排序,使用该方法时会自动生成合适的排序sql
        /// </summary>
        /// <param name="sql">含rownumber计算行号函数字段的查询语句</param>
        /// <param name="rows">行数</param>
        /// <param name="page">页码</param>
        /// <returns></returns>
        public string GetPagingSql(string sql, int rows, int page)
        {
            if (page == 0)
            {
                page = 1;
            }
            int startrow = (page - 1) * rows + 1;
            int endrow = rows * page == 0 ? 10 : rows * page;
            if (GetEasyUiDataGridSort() != "" && GetEasyUiDataGridOrder() != "")//easyui表格排序
            {
                sql = sql.ToLower();
                //以补位形式,长度暂时为50,去进行排序,使字符型和数字型的排序都能正确,另外也处理了日期型的字符串
                //string rpStr = "select row_number() over(order by (replicate(0, 50-len(convert(varchar(50),{0}, 23))) + convert(varchar(50),{0}, 23)) {1}) as rownumber,";
                string rpStr = "select row_number() over(order by {0} {1}) as rownumber,";
                rpStr = string.Format(rpStr, GetEasyUiDataGridSort(), GetEasyUiDataGridOrder());
                sql = Regex.Replace(
                    sql,
                    @"select row_number\(\) over\(order by \S+\) as rownumber,",
                    rpStr);
                sql = Regex.Replace(
                    sql,
                    @"select row_number\(\) over\(order by \S+ \S+\) as rownumber,",
                    rpStr);
            }
            string newsql = "select * from (" + sql + ") as PagingSqlTb where rownumber between " + startrow + " and " + endrow;
            return newsql;
        }

        /// <summary>
        /// 生成查询总数的sql
        /// </summary>
        /// <param name="sql"></param>
        /// <returns>生成查询总数的sql</returns>
        public string GetCountSql(string sql)
        {
            return "select count(*) from(" + sql + ") as CountSqlTb";
        }

        /// <summary>
        /// 生成汇总sql
        /// </summary>
        /// <param name="sql">原始的查询sql</param>
        /// <param name="param">(需要汇总的字段)可变的方法参数</param>
        /// <returns></returns>
        public string GetSummarySql(string sql, params string[] param)
        {
            string SummarySql = "select";
            for (int i = 0; i < param.Length; i++)
            {
                SummarySql += " " + "isnull(sum(" + param[i] + "),0) as " + param[i];
                if (i <= param.Length - 2)
                {
                    SummarySql += ", ";
                }
                if (i == param.Length - 1)//最后一个参数
                {
                    SummarySql += " ";
                }
            }
            return SummarySql + " from(" + sql + ") as SummarySqlTb";
        }

        /// <summary>
        /// 生成带事务的sql
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public string GetTranSql(string sql)
        {
            string TranSql = @"
                            set xact_abort on
                            begin tran
                                {0}
                            if @@error<>0
                                begin 
                                    rollback tran
                                end
                            else 
                                begin
                                    commit tran
                                end
                            ";
            TranSql = string.Format(TranSql, sql);
            return TranSql;
        }
        #endregion

        #region--------------------------------设置相关信息--------------------------------
        /// <summary>
        /// 设置 cookies(键,值,毫秒)
        /// </summary>
        /// <param name="name">键</param>
        /// <param name="value">值</param>
        /// <param name="ms">毫秒</param>
        public void SetCookies(string name, string value, double ms)
        {
            value = GlobalObject.encodeURIComponent(value);
            HttpCookie cookie = new HttpCookie(name);
            cookie.Value = value;
            cookie.Expires = DateTime.Now.AddMilliseconds(ms);
            HttpContext.Current.Response.Cookies.Add(cookie);
        }

        /// <summary>
        /// 设置session(键,值)
        /// </summary>
        /// <param name="name">键</param>
        /// <param name="value">值</param>
        public void SetSession(string name, string value)
        {
            HttpContext.Current.Session[name] = value;
        }

        /// <summary>
        /// 设置session(键,值)
        /// </summary>
        /// <param name="name">键</param>
        /// <param name="value">值</param>
        public void SetSession(string name, object value)
        {
            HttpContext.Current.Session[name] = value;
        }

        /// <summary>
        /// 通过委托实现类似js的回调函数
        /// </summary>
        /// <param name="DBID">DBID</param>
        /// <returns></returns>
        public delegate object GetData(string DBID);

        /// <summary>
        /// 设置缓存
        /// </summary>
        /// <param name="CacheName">缓存名字</param>
        /// <param name="s">缓存保持时间 秒</param>
        /// <param name="DBID">DBID</param>
        /// <param name="GetData">回调函数</param>
        /// <returns>缓存</returns>
        public object SetCache(string CacheName, int s, string DBID, GetData GetData)
        {
            Cache MyCache = HttpRuntime.Cache;
            if (MyCache[CacheName] == null) //判断是否存在缓存
            {
                var data = GetData(DBID);
                //设置缓存
                MyCache.Add(
                    CacheName,
                    data,
                    null,
                    DateTime.Now.AddSeconds(s),//保持时间 秒
                    TimeSpan.Zero,
                    CacheItemPriority.Normal,
                    null);
            }
            return MyCache[CacheName];
        }

        /// <summary>
        /// 设置缓存
        /// </summary>
        /// <param name="CacheName"></param>
        /// <param name="s"></param>
        /// <param name="data"></param>
        public void SetCache(string CacheName, int s, object data)
        {
            Cache MyCache = HttpRuntime.Cache;
            if (MyCache[CacheName] == null) //判断是否存在缓存
            {
                MyCache.Add(
                  CacheName,
                  data,
                  null,
                  DateTime.Now.AddSeconds(s),//保持时间 秒
                  TimeSpan.Zero,
                  CacheItemPriority.Normal,
                  null);
            }
        }
        #endregion

        #region--------------------------------获取相关信息--------------------------------
        /// <summary>
        /// 获取配置文件 connectionStrings 信息
        /// </summary>
        /// <param name="name">connectionStrings 节点中的键</param>
        /// <returns>相关值</returns>
        public string GetConnStrByWebConfig(string name)
        {
            return ConfigurationManager.ConnectionStrings[name].ConnectionString;
        }

        /// <summary>
        /// 获取配置文件 appSettings 信息
        /// </summary>
        /// <param name="name">appSettings 节点中的键</param>
        /// <returns>相关值</returns>
        public string GetAppSetByWebConfig(string name)
        {
            return ConfigurationManager.AppSettings[name].ToString();
        }

        /// <summary>
        /// 获取session 获取失败为空字符串
        /// </summary>
        /// <param name="name">session名</param>
        /// <returns>session值</returns>
        public string GetSession(string name)
        {
            if (HttpContext.Current.Session[name] != null)
            {
                return HttpContext.Current.Session[name].ToString();
            }
            return "";
        }

        /// <summary>
        ///  获取session 获取失败为null
        /// </summary>
        /// <param name="name"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public object GetSession(string name, string type)
        {
            if (type == "CusObj")
            {
                return HttpContext.Current.Session[name];
            }
            return null;
        }

        /// <summary>
        /// 获取 cookies 获取失败为空字符串
        /// </summary>
        /// <param name="name">cookies名</param>
        /// <returns>cookies 值</returns>
        public string GetCookies(string name)
        {
            string result = "";
            if (HttpContext.Current.Request.Cookies[name] != null)
            {
                result = HttpContext.Current.Request.Cookies[name].Value;
                result = GlobalObject.decodeURIComponent(result);
            }
            return result;
        }

        /// <summary>
        /// 获取 post 参数 获取失败为空字符串
        /// </summary>
        /// <param name="name">参数名</param>
        /// <returns>post 参数值</returns>
        public string GetPostParam(string name)
        {
            if (HttpContext.Current.Request.Form[name] != null)
            {
                return HttpContext.Current.Request.Form[name];
            }
            return "";
        }

        /// <summary>
        /// 获取 url 参数 获取失败为空字符串
        /// </summary>
        /// <param name="name">参数名</param>
        /// <returns>url 参数值</returns>
        public string GetUrlParam(string name)
        {
            if (HttpContext.Current.Request.QueryString[name] != null)
            {
                return HttpContext.Current.Request.QueryString[name];
            }
            return "";
        }

        /// <summary>
        /// 获取自定义参数中的值 获取失败为空字符串
        /// </summary>
        /// <param name="name">键</param>
        /// <param name="CusParamLst">类似url的查找参数的字符串</param>
        /// <returns>值</returns>
        public string GetCusParam(string name, string CusParamLst)
        {
            CusParamLst = CusParamLst.Replace("?", "");
            string[] arr = CusParamLst.Split('&');
            string result = "";
            for (int i = 0; i < arr.Length; i++)
            {
                if (arr[i].Contains(name + "="))
                {
                    result = arr[i].Replace(name + "=", "");
                    break;
                }
            }
            return result;
        }

        /// <summary>
        /// 获取 easyui 表格控件 页码 参数, 默认为 1
        /// </summary>
        /// <returns>页码</returns>
        public int GetEasyUiDataGridPage()
        {
            string page = GetPostParam("page");
            if (page == "")
            {
                page = "1";
            }
            return Int32.Parse(page);
        }

        /// <summary>
        /// 获取 easyui 表格控件 行数 参数,默认为 10
        /// </summary>
        /// <returns>行数</returns>
        public int GetEasyUiDataGridRows()
        {
            string rows = GetPostParam("rows");
            if (rows == "")
            {
                rows = "10";
            }
            return Int32.Parse(rows);
        }

        /// <summary>
        /// 获取 easyui 表格控件 排序字段, 默认为 ""
        /// </summary>
        /// <returns>排序字段</returns>
        public string GetEasyUiDataGridSort()
        {
            return GetPostParam("sort");
        }

        /// <summary>
        /// 获取 easyui 表格控件 排序规则,默认为 asc
        /// </summary>
        /// <returns>排序规则</returns>
        public string GetEasyUiDataGridOrder()
        {
            return GetPostParam("order");
        }

        /// <summary>
        /// 获取缓存
        /// </summary>
        /// <param name="CacheName"></param>
        /// <returns></returns>
        public object GetCache(string CacheName)
        {
            Cache MyCache = HttpRuntime.Cache;
            return MyCache[CacheName];
        }
        #endregion

        #region--------------------------------清空相关信息--------------------------------
        /// <summary>
        /// 清空所有缓存
        /// </summary>
        public void ClearAllCache()
        {
            //清空所有缓存
            Cache UserPowerCache = HttpRuntime.Cache;
            IDictionaryEnumerator CacheEnum = UserPowerCache.GetEnumerator();
            ArrayList al = new ArrayList();
            while (CacheEnum.MoveNext())
            {
                al.Add(CacheEnum.Key);
            }
            foreach (string key in al)
            {
                UserPowerCache.Remove(key);
            }
        }

        /// <summary>
        /// 清空所有cookies
        /// </summary>
        public void ClearAllCookies()
        {
            string[] cookies = HttpContext.Current.Request.Cookies.AllKeys;
            foreach (string name in cookies)
            {
                SetCookies(name, "", -1);
            }
        }

        /// <summary>
        /// 清空所有session
        /// </summary>
        public void ClearAllSession()
        {
            HttpContext.Current.Session.RemoveAll();
            HttpContext.Current.Session.Abandon();
        }
        #endregion

        #region-------------------------------- 验证码相关 --------------------------------
        /// <summary>
        /// 生成验证码
        /// </summary>
        /// <param name="length">指定验证码的长度</param>
        /// <returns>验证码</returns>
        public string CreateValidateCode(int length)
        {
            int[] randMembers = new int[length];
            int[] validateNums = new int[length];
            string validateNumberStr = "";
            //生成起始序列值
            int seekSeek = unchecked((int)DateTime.Now.Ticks);
            Random seekRand = new Random(seekSeek);
            int beginSeek = (int)seekRand.Next(0, Int32.MaxValue - length * 10000);
            int[] seeks = new int[length];
            for (int i = 0; i < length; i++)
            {
                beginSeek += 10000;
                seeks[i] = beginSeek;
            }
            //生成随机数字
            for (int i = 0; i < length; i++)
            {
                Random rand = new Random(seeks[i]);
                int pownum = 1 * (int)Math.Pow(10, length);
                randMembers[i] = rand.Next(pownum, Int32.MaxValue);
            }
            //抽取随机数字
            for (int i = 0; i < length; i++)
            {
                string numStr = randMembers[i].ToString();
                int numLength = numStr.Length;
                Random rand = new Random();
                int numPosition = rand.Next(0, numLength - 1);
                validateNums[i] = Int32.Parse(numStr.Substring(numPosition, 1));
            }
            //生成验证码
            for (int i = 0; i < length; i++)
            {
                validateNumberStr += validateNums[i].ToString();
            }
            return validateNumberStr;
        }

        /// <summary>
        /// 创建验证码的图片
        /// </summary>
        /// <param name="ValidateCode">验证码</param>
        /// <returns>二进制字节流</returns>
        public byte[] CreateValidateGraphic(string ValidateCode)
        {
            Bitmap image = new Bitmap((int)Math.Ceiling(ValidateCode.Length * 12.0), 22);
            Graphics g = Graphics.FromImage(image);
            try
            {
                //生成随机生成器
                Random random = new Random();
                //清空图片背景色
                g.Clear(Color.White);
                //画图片的干扰线
                for (int i = 0; i < 25; i++)
                {
                    int x1 = random.Next(image.Width);
                    int x2 = random.Next(image.Width);
                    int y1 = random.Next(image.Height);
                    int y2 = random.Next(image.Height);
                    g.DrawLine(new Pen(Color.Silver), x1, y1, x2, y2);
                }
                Font font = new Font("Arial", 12, (FontStyle.Bold | FontStyle.Italic));
                LinearGradientBrush brush = new LinearGradientBrush(new Rectangle(0, 0, image.Width, image.Height),
                 Color.Blue, Color.DarkRed, 1.2f, true);
                g.DrawString(ValidateCode, font, brush, 3, 2);
                //画图片的前景干扰点
                for (int i = 0; i < 100; i++)
                {
                    int x = random.Next(image.Width);
                    int y = random.Next(image.Height);
                    image.SetPixel(x, y, Color.FromArgb(random.Next()));
                }
                //画图片的边框线
                g.DrawRectangle(new Pen(Color.Silver), 0, 0, image.Width - 1, image.Height - 1);
                //保存图片数据
                MemoryStream stream = new MemoryStream();
                image.Save(stream, ImageFormat.Jpeg);
                //输出图片流
                return stream.ToArray();
            }
            finally
            {
                g.Dispose();
                image.Dispose();
            }
        }
        #endregion

        #region-------------------------------- ***其它*** --------------------------------
        /// <summary>
        /// DataTable 转 Json(不进行unicode编码)
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        public string DataTable2Json(DataTable dt)
        {
            return DataTable2Json(dt, false, false);
        }

        /// <summary>
        /// DataTable 转 Json
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="IsUnicode">是否进行unicode编码</param>
        public string DataTable2Json(DataTable dt, bool IsUnicode)
        {
            return DataTable2Json(dt, IsUnicode, false);
        }

        /// <summary>
        /// DataTable 转 Json
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="IsUnicode">是否进行unicode编码</param>
        /// <param name="IsStandard">是否标准格式的json</param>
        /// <returns></returns>
        public string DataTable2Json(DataTable dt, bool IsUnicode, bool IsStandard)
        {
            int RowCount = dt.Rows.Count;//行数
            int ColumnCount = dt.Columns.Count;//列数
            StringBuilder RowStr = new StringBuilder();
            for (int i = 0; i < RowCount; i++)
            {
                StringBuilder ColumnStr = new StringBuilder();
                for (int j = 0; j < ColumnCount; j++)
                {
                    ColumnStr.Append("\"");
                    ColumnStr.Append(dt.Columns[j]);
                    ColumnStr.Append("\":\"");
                    if (IsUnicode)
                    {
                        ColumnStr.Append(Str2Unicode(dt.Rows[i][j].ToString()));//unicode编码
                    }
                    else
                    {
                        ColumnStr.Append(dt.Rows[i][j].ToString());
                    }
                    ColumnStr.Append("\"");
                    if (j <= ColumnCount - 2)
                    {
                        ColumnStr.Append(",");
                    }
                }
                RowStr.Append("{");
                RowStr.Append(ColumnStr);
                RowStr.Append("}");
                if (i <= RowCount - 2)
                {
                    RowStr.Append(",");
                }
            }
            if (IsStandard)
            {
                return "[" + RowStr + "]";
            }
            else
            {
                return "{\"total\":\"" + RowCount + "\",\"Row\":[" + RowStr + "]}";
            }
        }

        /// <summary>
        /// Json 转 DataTable
        /// </summary>
        /// <param name="json">json字符串</param>
        /// <returns></returns>
        public DataTable Json2DataTable(string json)
        {
            DataTable table = null;
            if (json == "")
            {
                return table;
            }
            else
            {
                table = new DataTable();
                Regex regex = new Regex("\"Id\":\"(.*?)\"", RegexOptions.IgnoreCase);
                string str = regex.Match(json).Groups[1].Value;
                JsonSerializerSettings settings = new JsonSerializerSettings();
                json = json.Substring(json.IndexOf("["));
                json = json.TrimEnd(new char[] { '}' });
                return JsonConvert.DeserializeObject<DataTable>(json);
            }
        }

        /// <summary>
        /// MD5加密
        /// </summary>
        /// <param name="str">待加密的字符串</param>
        /// <returns>MD5字符串</returns>
        public string Str2MD5(string str)
        {
            return System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(str, "MD5");
        }

        /// <summary>
        /// 跳转到指定页面
        /// </summary>
        /// <param name="url">url</param>
        public void Redirect(string url)
        {
            HttpContext.Current.Response.Clear();
            HttpContext.Current.Response.Redirect(url, false);
            HttpContext.Current.Response.End();
        }

        /// <summary>
        /// 生成键值对 字符串
        /// </summary>
        /// <param name="dt">DataTable(以第一行数据为准)</param>
        /// <returns>{ key:value, key:value} 形式的字符串</returns>
        public string GetKeyValueStr(DataTable dt)
        {
            string result = "{";
            if (dt.Rows.Count != 0)
            {
                int DtColumnsCount = dt.Columns.Count;
                for (int i = 0; i < DtColumnsCount; i++)//遍历列
                {
                    result += "\"" + dt.Columns[i] + "\":\"" + dt.Rows[0][i].ToString() + "\"";
                    if (i != DtColumnsCount - 1)
                    {
                        result += ",";
                    }
                }
            }
            result += "}";
            return result;
        }

        /// <summary>
        /// 去除小数后面多余的0       1.0100 --> 1.01
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public string GetNumRemoveExcessZero(string str)
        {
            string[] result = str.Split('.');//拆分整数和小数部分
            double flag;
            if (double.TryParse(str, out flag) && result.Length == 2)//小数
            {
                return str.TrimEnd('0').TrimEnd('.');
            }
            else
            {
                return str;//非小数原样返回
            }
        }

        /// <summary>
        /// 生成二维表格字符串(数据源DataTable、表格和并列相关信息( , 号分隔)、表格和并列相关信息( , 号分隔)、大标题列表( , 号分隔)、列字段的标题列表、列字段的id列表、是否将表格的数字去掉多余的0)
        /// </summary>
        /// <param name="dt">数据源DataTable</param>
        /// <param name="BigTitles">大标题列表( , 号分隔)</param>
        /// <param name="FirstRowTitles">表格和并列相关信息( , 号分隔)</param>
        /// <param name="FirstRowColspans">表格和并列相关信( , 号分隔)</param>
        /// <param name="ColTitles">列字段的标题列表( , 号分隔)</param>
        /// <param name="ColFields">列字段的id列表( , 号分隔)</param>
        /// <param name="IsRemoveExcessZero">是否将表格的数字去掉多余的0</param>
        /// <returns>Table格式的字符串</returns>
        public string GetTableStr(DataTable dt, string BigTitles, string FirstRowTitles, string FirstRowColspans, string ColTitles, string ColFields, bool IsRemoveExcessZero)
        {
            string[] BigTitlesArr = BigTitles.TrimEnd(',').Split(',');//大标题
            string[] FirstRowTitlesArr = FirstRowTitles.TrimEnd(',').Split(',');//表格和并列相关信息
            string[] FirstRowColspansArr = FirstRowColspans.TrimEnd(',').Split(',');
            string[] ColTitlesArr = ColTitles.TrimEnd(',').Split(',');//表格列字段的标题
            string[] ColFieldsArr = ColFields.TrimEnd(',').Split(',');//表格列字段的id
            StringBuilder result = new StringBuilder();

            result.Append("<table border=1 cellspan=0 cellpading=0>");

            //生成标题
            for (int i = 0; i < BigTitlesArr.Length; i++)
            {
                if (i == 0)
                {
                    result.Append("<tr style='text-align:center;'>");
                    result.Append("<td colspan='" + ColTitlesArr.Length + "'><h2>" + BigTitlesArr[i] + "</h2></td>");//大标题
                }
                else
                {
                    result.Append("<tr style='text-align:left;'>");
                    result.Append("<td colspan='" + ColTitlesArr.Length + "'><h4>" + BigTitlesArr[i] + "</h4></td>");//小标题
                }
                result.Append("</tr>");
            }

            //生成表头

            //合并列表头信息
            if (FirstRowTitles != "" && FirstRowColspans != "" && FirstRowTitlesArr.Length == FirstRowColspansArr.Length)
            {
                result.Append("<tr>");
                for (int i = 0; i < FirstRowTitlesArr.Length; i++)
                {
                    result.Append("<td style='width:80px;height:50px;text-align:center;' colspan='" + FirstRowColspansArr[i] + "'>" + FirstRowTitlesArr[i] + "</td>");
                }
                result.Append("</tr>");
            }

            //非合并列表头信息
            result.Append("<tr>");
            for (int i = 0; i < ColTitlesArr.Length; i++)
            {
                result.Append("<td style='width:80px;height:50px;text-align:center;'>" + ColTitlesArr[i] + "</td>");
            }
            result.Append("</tr>");

            //生成表内容
            for (int i = 0; i < dt.Rows.Count; i++)
            {
                result.Append("<tr style='text-align:center;'>");
                for (int n = 0; n < ColFieldsArr.Length; n++)
                {
                    if (IsRemoveExcessZero)
                    {
                        result.Append("<td>" + GetNumRemoveExcessZero(dt.Rows[i][ColFieldsArr[n]].ToString()) + "</td>");
                    }
                    else
                    {
                        result.Append("<td>" + dt.Rows[i][ColFieldsArr[n]].ToString() + "</td>");
                    }
                }
                result.Append("</tr>");
            }

            result.Append("</table>");
            return result.ToString();
        }

        /// <summary>
        /// str 转 unicode
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public string Str2Unicode(string str)
        {
            StringBuilder result = new StringBuilder();
            if (!string.IsNullOrEmpty(str))
            {
                for (int i = 0; i < str.Length; i++)
                {
                    result.Append("\\u");

                    string tmp = ((int)str[i]).ToString("x");
                    string zerotmp = "";
                    for (int j = 0; j < 4 - tmp.Length; j++)
                    {
                        zerotmp += "0";//不够4位需要补0
                    }

                    result.Append(zerotmp + tmp);
                }
            }
            return result.ToString();
        }

        /// <summary>
        /// unicode 转 str
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public string Unicode2Str(string str)
        {
            return System.Text.RegularExpressions.Regex.Unescape(str);
        }

        /// <summary>
        /// 将Json序列化的时间由 /Date(1304931520336+0800)/ 转为字符串
        /// </summary>
        private string Tmp_JsonDate2Str(Match m)
        {
            string result = string.Empty;
            DateTime dt = new DateTime(1970, 1, 1);
            dt = dt.AddMilliseconds(long.Parse(m.Groups[1].Value) - 1000 * 60 * 60 * 8);
            dt = dt.ToLocalTime();
            result = dt.ToString("yyyy-MM-dd HH:mm:ss");
            return result;
        }

        /// <summary>
        /// 将Json序列化的时间由 /Date(1304931520336+0800)/ 转为字符串
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public string JsonDate2Str(string str)
        {
            MatchEvaluator mer = new MatchEvaluator(Tmp_JsonDate2Str);
            Regex reg = new Regex(@"\\/Date\((\d+)\)\\/");
            return reg.Replace(str, mer);
        }
        #endregion
    }
}