using System;
using System.Security.Cryptography;
using System.Data;
using System.Data.SqlClient;
using System.Collections;
using System.Text.RegularExpressions;
using System.IO;
using System.Text;
using System.Web.Security;
using System.Drawing;
using System.Web;
using System.Net;
using System.Runtime.Serialization.Formatters.Binary;
using System.Xml;
using System.Data.OleDb;

namespace UUN
{
    /// <summary>
    /// 常用的方法
    /// </summary>
    public static class 常用
    {
        /// <summary>
        /// 返回一段随机的字母数字组合的指定数量的字符串
        /// </summary>
        /// <param name="数量">生成字符串的数量</param>
        /// <returns>生成的结果</returns>
        public static String 随机字符(int 数量)
        {
            //获取随机数
            byte[] 数组 = new byte[数量];
            char[] 字符数组 = "01234567890QWERTYUIOPASDFGHJKLZXCVBNM".ToCharArray();
            RNGCryptoServiceProvider RN = new RNGCryptoServiceProvider();
            RN.GetBytes(数组);
            //转成字符串并返回
            String 返回值 = "";
            for (int i = 0; i < 数组.Length; i++)
                返回值 += 字符数组[数组[i] % 字符数组.Length];
            return 返回值;
        }
        /// <summary>
        /// 获取一个指定最大值与0之间的随机数字
        /// </summary>
        /// <param name="最大值">随机数的最大值，不包含最大值。</param>
        /// <returns>生成的随机数</returns>
        public static int 随机数(int 最大值)
        {
            if (最大值 < 1)
                return 0;
            Byte[] B = new byte[1];
            RNGCryptoServiceProvider RN = new RNGCryptoServiceProvider();
            RN.GetBytes(B);
            return B[0] % 最大值;
        }
        /// <summary>
        /// 获取留言表情选择代码
        /// </summary>
        /// <returns></returns>
        public static String 获取留言表情代码()
        {
            String 返回值 = @"
<select name=""LiuYanBiaoQing"">
<option value="""">无</option>
";
            DataSet 数据 = (DataSet)HttpContext.Current.Application["UUN_UUN3G_LiuYanBiaoQing"];
            for (int i = 0; i < 数据.Tables[0].Rows.Count; i++)
            {
                DataRow 行 = 数据.Tables[0].Rows[i];
                返回值 += "<option value=\"" +HttpUtility.HtmlEncode(行["表情名称"].ToString()) + "\">" + HttpUtility.HtmlEncode(行["表情名称"].ToString()) + "</option>";
            }
            返回值 += "</select>";
            return 返回值;
        }
        /// <summary>
        /// 根据表情名称获取图片
        /// </summary>
        /// <param name="表情名称"></param>
        /// <returns></returns>
        public static String 获取留言表情图片(String 表情名称)
        {
            if (表情名称 == "")
                return "";
            String 图片地址 = "";
            DataSet 数据 = (DataSet)HttpContext.Current.Application["UUN_UUN3G_LiuYanBiaoQing"];
            for (int i = 0; i < 数据.Tables[0].Rows.Count; i++)
            {
                DataRow 行 = 数据.Tables[0].Rows[i];
                if (行["表情名称"].ToString() == 表情名称)
                    图片地址 = 行["表情图片"].ToString();
            }

            if (图片地址 == "")
                return "";
            else
                return "<img src=\"" + HttpUtility.HtmlEncode(图片地址) + "\" alt=\"图片\" />";
        }
        /// <summary>
        /// 获取一个数据行的集合
        /// </summary>
        /// <param name="语句">生成集合的数据库查询语句</param>
        /// <returns>数据行集合</returns>
        public static Hashtable SQL_获取(SqlCommand 语句)
        {
            Hashtable 返回值;

            SqlDataReader 读取 = 语句.ExecuteReader();
            if (读取.Read())
            {
                返回值 = new Hashtable();
                for (int i = 0; i < 读取.FieldCount; i++)
                    返回值.Add(读取.GetName(i), 读取[i]);
            }
            else
                返回值 = null;
            读取.Close();

            return 返回值;
        }
        /// <summary>
        /// 获取指定数据表的最大ID
        /// </summary>
        /// <param name="连接">此次查询使用的数据库连接</param>
        /// <param name="表名称">数据表的名称</param>
        /// <returns>该表的最大ID</returns>
        public static int SQL_最高ID(SqlConnection 连接, String 表名称)
        {
            SqlCommand 语句 = new SqlCommand("SELECT [ID] FROM [" + 表名称 + "] ORDER BY [ID] DESC", 连接);
            SqlDataReader 读取 = 语句.ExecuteReader();

            int 返回值;
            if (读取.Read())
                返回值 = Convert.ToInt32(读取["ID"]) + 1;
            else
                返回值 = 1;
            读取.Close();

            return 返回值;
        }
        /// <summary>
        /// 获取指定数据表的最高楼数
        /// </summary>
        /// <param name="连接">数据库连接对象</param>
        /// <param name="查询条件">数据库查询条件</param>
        /// <param name="表名称">数据表名称</param>
        /// <returns></returns>
        public static int SQL_最高楼数(SqlConnection 连接,String 查询条件, String 表名称)
        {
            SqlCommand 语句 = new SqlCommand("SELECT [楼数] FROM [" + 表名称 + "]"+查询条件+" ORDER BY [楼数] DESC", 连接);
            SqlDataReader 读取 = 语句.ExecuteReader();

            int 返回值;
            if (读取.Read())
                返回值 = Convert.ToInt32(读取["楼数"]) + 1;
            else
                返回值 = 1;
            读取.Close();

            return 返回值;
        }
        /// <summary>
        /// 增加一个不重复的SQL语句字段
        /// </summary>
        /// <param name="字段内容"></param>
        /// <param name="新增字段"></param>
        /// <returns></returns>
        public static String SQL_增加非重复字段(String 字段内容, String 新增字段)
        {
            if (字段内容.IndexOf("[" + 新增字段 + "]") == -1)
                字段内容 += ",[" + 新增字段 + "]";
            return 字段内容;
        }
        /// <summary>
        /// 生成SQL搜索条件语句
        /// </summary>
        /// <param name="关键字">搜索关键字</param>
        /// <param name="字段">查询的字段，多个用“,”隔开。</param>
        /// <returns></returns>
        public static String SQL_搜索条件(String 关键字, String 字段)
        {
            String 返回值 = "";
            if (关键字 == "" || 字段 == ""||关键字==null||字段==null)
                return "1=1";

            String[] 字段数组 = 字段.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
            String[] 关键字数组 = 关键字.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
            for (int i = 0; i < 字段数组.Length; i++)
                for (int i1 = 0; i1 < 关键字数组.Length; i1++)
                    if (返回值 == "")
                        返回值 += "CHARINDEX('" + 关键字数组[i1].Replace("'", "") + "',[" + 字段数组[i] + "])>0";
                    else
                        返回值 += " OR CHARINDEX('" + 关键字数组[i1].Replace("'", "") + "',[" + 字段数组[i] + "])>0";

            return 返回值;
        }
        /// <summary>
        /// 过滤SQL注入字符
        /// </summary>
        /// <param name="SQL"></param>
        /// <returns></returns>
        public static String SQL_过滤注入(String SQL)
        {
            return SQL.Replace("'", "''");
        }
        /// <summary>
        /// 将一行的数据复制并返回
        /// </summary>
        /// <param name="数据表">数据库表对象</param>
        /// <param name="数据行">数据行对象</param>
        /// <returns></returns>
        public static DataRow 数据_复制行(DataTable 数据表, DataRow 数据行)
        {
            DataRow 返回值 = 数据表.NewRow();
            foreach (DataColumn 列 in 数据表.Columns)
                返回值[列.ColumnName] = 数据行[列.ColumnName];

            return 返回值;
        }
        /// <summary>
        /// XML文件的最高ID
        /// </summary>
        /// <param name="文件夹">XML文件所属文件夹</param>
        /// <returns></returns>
        public static int XML_最高ID(DirectoryInfo 文件夹)
        {
            int 返回值 = 0;
            FileInfo[] FIS = 文件夹.GetFiles();
            for (int i = 0; i < FIS.Length; i++)
            {
                String 文件名称 = FIS[i].Name;
                int ID = Convert.ToInt32(文件名称.Substring(0, 文件名称.IndexOf('.')));
                if (ID > 返回值)
                    返回值 = ID;
            }

            return 返回值 + 1;
        }
        /// <summary>
        /// 将文件根据文件名进行重新排序。
        /// </summary>
        /// <param name="FIS">文件数组。</param>
        /// <returns></returns>
        public static FileInfo[] XML_重新排序(FileInfo[] FIS)
        {
            FileInfo[] 返回值 = new FileInfo[FIS.Length];

            SortedList 数组 = new SortedList();
            int[] 数字数组 = new int[FIS.Length];
            for (int i = 0; i < FIS.Length; i++)
            {
                FileInfo FI = FIS[i];
                数组.Add(FI.Name, FI);
                数字数组[i] = Convert.ToInt32(FI.Name.Substring(0, FI.Name.IndexOf('.')));
            }

            数字数组=数字排序(数字数组);

            for (int i = 0; i < 数字数组.Length; i++)
                返回值[i] = (FileInfo)数组[数字数组[i]+".xml"];

            return 返回值;
        }
        /// <summary>
        /// 将数字数据进行重新排序
        /// </summary>
        /// <param name="数组">数字数组</param>
        /// <returns></returns>
        public static int[] 数字排序(int[] 数组)
        {
            if (数组.Length < 1)
                return 数组;
            for (int i = 0; i < 数组.Length; i++)
                for (int i1 = 0; i1 < 数组.Length-i-1; i1++)
                    if (数组[i1] > 数组[i1 + 1])
                    {
                        int 值=数组[i1];
                        数组[i1] = 数组[i1 + 1];
                        数组[i1 + 1] = 值;
                    }
            return 数组;
        }
        /// <summary>
        /// 获取默认网页内容
        /// </summary>
        /// <param name="标题">文件的标题</param>
        /// <param name="是否WAP">是否WAP文件</param>
        /// <returns></returns>
        public static String 网页_获取默认内容(String 标题,bool 是否WAP)
        {
            if(是否WAP)
                return @"<?xml version=""1.0"" encoding=""utf-8""?>
<!DOCTYPE wml PUBLIC ""-//WAPFORUM//DTD WML 1.1//EN"" ""http://www.wapforum.org/DTD/wml_1.1.xml"">
<wml>
<head>
<meta http-equiv=""Cache-Control"" content=""max-age=0"" />
</head>

<card title=""" + HttpUtility.HtmlEncode(标题) + @""">
<p>
{$CMS:弹出消息$}



网页内容




</p>
</card>
</wml>";
            else
                return @"<?xml version=""1.0"" encoding=""UTF-8""?>
<!DOCTYPE html PUBLIC ""-//WAPFORUM//DTD XHTML Mobile 1.0//EN"" ""http://www.wapforum.org/DTD/xhtml-mobile10.dtd"">
<html xmlns=""http://www.w3.org/1999/xhtml"">
<head>
<meta http-equiv=""ContentType"" content=""text/html;charset=utf-8""/>
<meta http-equiv=""Cache-Control"" content=""max-age=0"" />
<title>" + HttpUtility.HtmlEncode(标题) + @"</title>
</head>
<body>
<div>
{$CMS:弹出消息$}

网页内容
</div>
</body>
</html>";
        }
        /// <summary>
        /// 根据版块ID获取版块的名称
        /// </summary>
        /// <param name="ID">版块ID</param>
        /// <returns></returns>
        public static String 获取版块名称(int ID)
        {
            DataSet 数据 = (DataSet)HttpContext.Current.Application["UUN_UUN3G_LunTanBanKuai"];
            for (int i = 0; i < 数据.Tables[0].Rows.Count; i++)
            {
                DataRow 行 = 数据.Tables[0].Rows[i];
                if (Convert.ToInt32(行["ID"]) == ID)
                    return 行["版块名称"].ToString();
            }
            return "";
        }
        /// <summary>
        /// 根据栏目ID获取栏目对象
        /// </summary>
        /// <param name="ID">栏目ID</param>
        /// <returns></returns>
        public static DataRow 获取栏目(int ID)
        {
            DataSet 数据 = (DataSet)HttpContext.Current.Application["UUN_UUN3G_NeiRongLanMu"];
            for (int i = 0; i < 数据.Tables[0].Rows.Count; i++)
            {
                DataRow 行 = 数据.Tables[0].Rows[i];
                if (Convert.ToInt32(行["ID"]) == ID)
                    return 行;
            }
            return null;
        }
        /// <summary>
        /// 根据版块ID获取版块对象
        /// </summary>
        /// <param name="ID">版块ID</param>
        /// <returns></returns>
        public static DataRow 获取版块(int ID)
        {
            DataSet 数据 = (DataSet)HttpContext.Current.Application["UUN_UUN3G_LunTanBanKuai"];
            for (int i = 0; i < 数据.Tables[0].Rows.Count; i++)
            {
                DataRow 行 = 数据.Tables[0].Rows[i];
                if (Convert.ToInt32(行["ID"]) == ID)
                    return 行;
            }
            return null;
        }
        /// <summary>
        /// 根据留言本ID获取留言本对象
        /// </summary>
        /// <param name="ID">留言本ID</param>
        /// <returns></returns>
        public static DataRow 获取留言本(int ID)
        {
            DataSet 数据 = (DataSet)HttpContext.Current.Application["UUN_UUN3G_LiuYanBen"];
            for (int i = 0; i < 数据.Tables[0].Rows.Count; i++)
            {
                DataRow 行 = 数据.Tables[0].Rows[i];
                if (Convert.ToInt32(行["ID"]) == ID)
                    return 行;
            }
            return null;
        }
        /// <summary>
        /// 网站数据缓存，用于在非访问对象中处理的文件
        /// </summary>
        /// <param name="HC">当前访问信息</param>
        public static void 更新缓存(HttpContext HC)
        {
            if (HC.Application["UUN_UUN3G_ZaiXianYongHuShu"] == null)
                new 访问(HC).开始处理("系统", "系统", "系统", null);
        }
        /// <summary>
        /// 随机显示一条广告内容
        /// </summary>
        /// <param name="所属分类">广告所属的分类</param>
        /// <param name="标识">用户的标识</param>
        /// <returns></returns>
        public static String 获取随机广告(int 所属分类,String 标识)
        {
            DataSet 数据 = (DataSet)HttpContext.Current.Application["UUN_UUN3G_GuangGao"];
            Hashtable 广告数据 = new Hashtable();
            int i1 = 0;
            for (int i = 0; i < 数据.Tables[0].Rows.Count; i++)
            {
                DataRow 行 = 数据.Tables[0].Rows[i];
                if (Convert.ToInt32(行["所属分类"]) == 所属分类)
                {
                    广告数据.Add(i1, 行);
                    i1++;
                }
            }

            if (广告数据.Count == 0)
                return "";

            DataRow 广告行 = (DataRow)广告数据[常用.随机数(广告数据.Count)];

            设置 广告内容 = new 设置(广告行["广告内容"].ToString());
            String 返回值 = "";
            if (广告行["广告类型"].ToString() == "链接")
            {
                String 图片地址 = 广告内容["图片地址"].ToString();
                String 链接标题 = 广告内容["链接标题"].ToString();
                String 链接地址 = 广告内容["链接地址"].ToString();

                返回值 = "<a href=\"" +
                    HttpUtility.HtmlEncode(常用.处理地址(链接地址, 标识)) +
                    "\">" +
                    (图片地址 != "" ? "<img src=\"" + HttpUtility.HtmlEncode(图片地址) + "\" alt=\"" + HttpUtility.HtmlEncode(链接标题) + "\" />" : HttpUtility.HtmlEncode(链接标题)) +
                    "</a>";
            }
            else
                返回值 = 广告内容["代码内容"].ToString();
            return 返回值;
        }
        /// <summary>
        /// 将文本中的关键字强调显示
        /// </summary>
        /// <param name="文字">文本内容。</param>
        /// <param name="关键字">搜索关键字。</param>
        /// <param name="是否颜色">关键字的显示方式，颜色显示或加粗显示。</param>
        /// <returns></returns>
        public static String 强调关键字(String 文字, String 关键字, bool 是否颜色)
        {
            if (关键字 == null || 关键字 == "")
                return 文字;
            String[] 关键字数组 = 关键字.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
            for (int i = 0; i < 关键字数组.Length; i++)
                文字 = 文字.Replace(关键字数组[i], 是否颜色 ? "<span style=\"color:#ff0000\">" + 关键字数组[i] + "</span>" : "<strong>" + 关键字数组[i] + "</strong>");

            return 文字;
        }
        /// <summary>
        /// 验证该用户是否为电脑用户。
        /// </summary>
        /// <param name="IP地址">用户的IP地址。</param>
        /// <param name="浏览器">用户使用的浏览器名。</param>
        /// <returns></returns>
        public static bool 是否电脑用户(String IP地址,String 浏览器)
        {
            //throw new Exception(浏览器.IndexOf("IE", StringComparison.OrdinalIgnoreCase).ToString());
            return 浏览器.IndexOf("IE", StringComparison.OrdinalIgnoreCase) > -1 || 浏览器.IndexOf("opera", StringComparison.OrdinalIgnoreCase) > -1;
        }
        /// <summary>
        /// 获取当前页的文章内容
        /// </summary>
        /// <param name="文章内容">文章全文的内容</param>
        /// <param name="当前页">文章的当前页位置</param>
        /// <param name="总页数">文章的总分页数</param>
        /// <param name="是否余下全部">是否显示余下全部文章内容</param>
        /// <returns></returns>
        public static String 获取文章分页内容(String 文章内容, int 当前页,int 总页数,int 一页显示文字数, bool 是否余下全部)
        {
            if (是否余下全部 || 当前页 == 总页数)
                return 文章内容.Substring((当前页 - 1) * 一页显示文字数);
            else
                return 文章内容.Substring((当前页 - 1) * 一页显示文字数, 一页显示文字数);
        }
        /// <summary>
        /// 应用内容的权限设置
        /// </summary>
        /// <param name="内容对象">数据内容对象</param>
        /// <param name="类型">内容的类型</param>
        /// <param name="访问">页面的访问信息</param>
        public static void 应用内容权限(Hashtable 内容对象,String 类型,访问 访问)
        {
            if (内容对象 == null)
                throw new Exception("内容不存在");
            if (Convert.ToBoolean(内容对象["是否审核"]))
                throw new Exception("该内容正在审核");
            if (Convert.ToString(内容对象["外部链接"])!="")
                访问.HC.Response.Redirect(常用.处理地址(内容对象["外部链接"].ToString(),访问.用户["标识"].ToString()));
            if (Convert.ToBoolean(内容对象["权限_仅限会员"]))
                    访问.验证会员();
            if (Convert.ToInt32(内容对象["权限_需要等级"]) > 0)
                访问.验证等级(Convert.ToInt32(内容对象["权限_需要等级"]));
            if (Convert.ToInt32(内容对象["权限_扣除积分"]) > 0)
                访问.验证扣除积分(类型, Convert.ToInt32(内容对象["ID"]));
        }
        /// <summary>
        /// 获取指定IP的所在省份和城市。
        /// </summary>
        /// <param name="IP地址">要查询的IP地址</param>
        /// <param name="省份">该IP的所在省份</param>
        /// <param name="城市">该IP的所在城市</param>
        public static void 获取城市(String IP地址, out String 省份, out String 城市)
        {
            省份 = "未知";
            城市 = "未知";
            if (!File.Exists(HttpContext.Current.Server.MapPath("~/Data/IPData/#DB#.mdb")))
                return;
            Int64 IP = IP转数字(IP地址);

            OleDbConnection 连接 = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + HttpContext.Current.Server.MapPath("~/Data/IPData/#DB#.mdb"));
            连接.Open();
            OleDbCommand 语句 = new OleDbCommand("SELECT [IP_Province],[IP_City] FROM [IPToCity] WHERE [IP_Start]<=? AND [IP_End]>=? ORDER BY [IP_ID] DESC", 连接);
            语句.Parameters.Add("@IP_Start",OleDbType.BigInt).Value = IP;
            语句.Parameters.Add("@IP_End", OleDbType.BigInt).Value = IP;

            OleDbDataReader 读取 = 语句.ExecuteReader();
            if (读取.Read())
            {
                省份 = Convert.ToString(读取["IP_Province"]);
                城市 = Convert.ToString(读取["IP_City"]);
            }
            else
            {
                省份 = "未知";
                城市 = "未知";
            }
            读取.Close();
            连接.Close();
        }
        /// <summary>
        /// 获取指定IP的所在省份和城市
        /// </summary>
        /// <param name="连接">此次查询使用的数据库连接</param>
        /// <param name="IP地址">要查询的IP地址</param>
        /// <returns>省份和城市</returns>
        public static String 获取城市(SqlConnection 连接, String IP地址)
        {
            String 省份, 城市;
            获取城市( IP地址, out 省份, out 城市);
            return 省份 == 城市 ? 省份 : 省份 + "省" + 城市 + "市";
        }
        public static Int64 IP转数字(String IP地址)
        {
            String[] IP数组 = IP地址.Split('.');

            Int64 返回值 = Convert.ToInt32(IP数组[0]) * 256 * 256 * 256 + Convert.ToInt32(IP数组[1]) * 256 * 256 + Convert.ToInt32(IP数组[2]) * 256 + Convert.ToInt32(IP数组[3]);
            return 返回值;
        }
        /// <summary>
        /// 显示所有的图片
        /// </summary>
        /// <param name="图片地址">所有图片地址，多张图使用“,”隔开</param>
        /// <returns></returns>
        public static String 显示所有图片(String 图片地址)
        {
            String[] 图片数组 = 图片地址.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
            String 返回值 = "";
            for (int i = 0; i < 图片数组.Length; i++)
                返回值 += "<img src=\"" + HttpUtility.HtmlEncode(图片数组[i]) + "\" alt=\"..\" />";
            return 返回值;
        }
        /// <summary>
        /// 根据图片内容显示一张图片
        /// </summary>
        /// <param name="图片地址">所有图片地址</param>
        /// <param name="内容类型">内容的类型</param>
        /// <param name="是否随机">图片是否随机显示</param>
        /// <returns></returns>
        public static String 显示图片(String 图片地址,String 内容类型, bool 是否随机)
        {
            if (图片地址 == "")
                return "";

            String[] 图片数组 = 图片地址.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

            if (是否随机)
                return "<img src=\"" + HttpUtility.HtmlEncode(图片数组[常用.随机数(图片数组.Length)]) + "\""+常用.获取图片宽度高度(内容类型)+" alt=\"IMG\" />";
            else
                return "<img src=\"" + HttpUtility.HtmlEncode(图片数组[图片数组.Length - 1]) + "\"" + 常用.获取图片宽度高度(内容类型) + " alt=\"IMG\" />";
        }
        /// <summary>
        /// 显示贴子的状态
        /// </summary>
        /// <param name="行">贴子的行数据。</param>
        /// <returns></returns>
        public static String 贴子状态代码(DataRow 行)
        {
            String 返回值 = "";
            if (Convert.ToBoolean(行["是否置顶"]))
                返回值 += Convert.ToBoolean(程序.设置["贴子状态_置顶_是否图标"]) ? Convert.ToString(程序.设置["贴子状态_置顶_值"]) : "<img src=\"" + HttpUtility.HtmlEncode(程序.安装位置 + "Images/TZZT/1.gif") + "\" alt=\"..\" />";
            if (Convert.ToBoolean(行["是否精华"]))
                返回值 += Convert.ToBoolean(程序.设置["贴子状态_精华_是否图标"]) ? Convert.ToString(程序.设置["贴子状态_精华_值"]) : "<img src=\"" + HttpUtility.HtmlEncode(程序.安装位置 + "Images/TZZT/2.gif") + "\" alt=\"..\" />";
            if (Convert.ToBoolean(行["是否锁定"]))
                返回值 += Convert.ToBoolean(程序.设置["贴子状态_锁定_是否图标"]) ? Convert.ToString(程序.设置["贴子状态_锁定_值"]) : "<img src=\"" + HttpUtility.HtmlEncode(程序.安装位置 + "Images/TZZT/3.gif") + "\" alt=\"..\" />";
            if (Convert.ToInt32(行["回贴数"]) > Convert.ToInt32(程序.设置["贴子状态_热门条件"]))
                返回值 += Convert.ToBoolean(程序.设置["贴子状态_热门_是否图标"]) ? Convert.ToString(程序.设置["贴子状态_热门_值"]) : "<img src=\"" + HttpUtility.HtmlEncode(程序.安装位置 + "Images/TZZT/4.gif") + "\" alt=\"..\" />";
            if (Convert.ToDateTime(行["发表时间"]) > DateTime.Now - new TimeSpan(1, 0, 0, 0))
                返回值 += Convert.ToBoolean(程序.设置["贴子状态_最新_是否图标"]) ? Convert.ToString(程序.设置["贴子状态_最新_值"]) : "<img src=\"" + HttpUtility.HtmlEncode(程序.安装位置 + "Images/TZZT/5.gif") + "\" alt=\"..\" />";
            if (Convert.ToInt32(行["贴子类型"]) == 1)
                返回值 += "[附]";

            return 返回值;
        }
        /// <summary>
        /// 显示贴子的状态
        /// </summary>
        /// <param name="行">贴子的行数据</param>
        /// <returns></returns>
        public static String 贴子状态代码(Hashtable 行)
        {
            String 返回值 = "";
            if (Convert.ToBoolean(行["是否置顶"]))
                返回值 += Convert.ToBoolean(程序.设置["贴子状态_置顶_是否图标"]) ? Convert.ToString(程序.设置["贴子状态_置顶_值"]) : "<img src=\"" + HttpUtility.HtmlEncode(程序.安装位置 + "Images/TZZT/1.gif") + "\" alt=\"..\" />";
            if (Convert.ToBoolean(行["是否精华"]))
                返回值 += Convert.ToBoolean(程序.设置["贴子状态_精华_是否图标"]) ? Convert.ToString(程序.设置["贴子状态_精华_值"]) : "<img src=\"" + HttpUtility.HtmlEncode(程序.安装位置 + "Images/TZZT/2.gif") + "\" alt=\"..\" />";
            if (Convert.ToBoolean(行["是否锁定"]))
                返回值 += Convert.ToBoolean(程序.设置["贴子状态_锁定_是否图标"]) ? Convert.ToString(程序.设置["贴子状态_锁定_值"]) : "<img src=\"" + HttpUtility.HtmlEncode(程序.安装位置 + "Images/TZZT/3.gif") + "\" alt=\"..\" />";
            if (Convert.ToInt32(行["回贴数"]) > Convert.ToInt32(程序.设置["贴子状态_热门条件"]))
                返回值 += Convert.ToBoolean(程序.设置["贴子状态_热门_是否图标"]) ? Convert.ToString(程序.设置["贴子状态_热门_值"]) : "<img src=\"" + HttpUtility.HtmlEncode(程序.安装位置 + "Images/TZZT/4.gif") + "\" alt=\"..\" />";
            if (Convert.ToDateTime(行["发表时间"]) > DateTime.Now - new TimeSpan(1, 0, 0, 0))
                返回值 += Convert.ToBoolean(程序.设置["贴子状态_最新_是否图标"]) ? Convert.ToString(程序.设置["贴子状态_最新_值"]) : "<img src=\"" + HttpUtility.HtmlEncode(程序.安装位置 + "Images/TZZT/5.gif") + "\" alt=\"..\" />";

            return 返回值;
        }
        /// <summary>
        /// 根据指定样式设置生成标题
        /// </summary>
        /// <param name="标题">内容的标题</param>
        /// <param name="标题样式_粗体">标题是否粗体</param>
        /// <param name="标题样式_斜体">标题是否斜体</param>
        /// <param name="标题样式_删除线">标题是否删除线</param>
        /// <param name="标题样式_颜色">标题颜色</param>
        /// <param name="字数">标题最长的字数长度</param>
        /// <returns></returns>
        public static String 标题样式(String 标题, bool 标题样式_粗体, bool 标题样式_斜体, bool 标题样式_删除线, String 标题样式_颜色, int 字数)
        {
            标题 = HttpUtility.HtmlEncode(截取字符串(标题, 字数));
            if (标题样式_粗体)
                标题 = "<strong>" + 标题 + "</strong>";
            if (标题样式_斜体)
                标题 = "<i>" + 标题 + "</i>";
            if (标题样式_删除线)
                标题 = "<strike>" + 标题 + "</strike>";
            if (标题样式_颜色 != "")
                标题 = "<font color=\"" + 标题样式_颜色 + "\">" + 标题 + "</font>";
            return 标题;
        }
        /// <summary>
        /// 使用通配符匹配一段文本
        /// </summary>
        /// <param name="文本内容">文本数据的内容</param>
        /// <param name="通配符规则">通配符模糊匹配的规则</param>
        /// <returns>是否匹配成功。</returns>
        public static bool 通配符匹配(String 文本内容, String 通配符规则)
        {
            if (文本内容 == null)
                return false;

            通配符规则 = 通配符转义(通配符规则);
            Regex 表达式 = new Regex(通配符规则);
            return 表达式.IsMatch(文本内容);
        }
        /// <summary>
        /// 获取图片的宽度高度设置
        /// </summary>
        /// <param name="内容类型">内容的类型</param>
        /// <returns></returns>
        public static String 获取图片宽度高度(String 内容类型)
        {
            if (!Convert.ToBoolean(程序.设置["显示设置_图片应用_" + 内容类型]))
                return "";
            int 图片宽度 = Convert.ToInt32(程序.设置["显示设置_页面图片宽度"]);
            int 图片高度 = Convert.ToInt32(程序.设置["显示设置_页面图片高度"]);
            return
                    (图片宽度 < 1 ? "" : " width=\"" + 图片宽度 + "\"") +
                    (图片高度 < 1 ? "" : " height=\"" + 图片高度 + "\"");
        }
        /// <summary>
        /// 获取头像的宽度高度设置
        /// </summary>
        /// <returns></returns>
        public static String 获取头像宽度高度()
        {
            int 图片宽度 = Convert.ToInt32(程序.设置["显示设置_会员头像宽度"]);
            int 图片高度 = Convert.ToInt32(程序.设置["显示设置_会员头像高度"]);
            return
                    (图片宽度 < 1 ? "" : " width=\"" + 图片宽度 + "\"") +
                    (图片高度 < 1 ? "" : " height=\"" + 图片高度 + "\"");
        }
        /// <summary>
        /// 将通配符规则转换成正则表达式规则
        /// </summary>
        /// <param name="通配符表达式">通配符的表达式</param>
        /// <returns>通配符转义的结果</returns>
        public static String 通配符转义(String 通配符表达式)
        {
            String 返回值 = 通配符表达式.Replace("\\", "\\\\")
                .Replace("^", "\\^")
                .Replace("$", "\\$")
                .Replace("+", "\\+")
                .Replace("{", "\\{")
                .Replace("}", "\\}")
                .Replace(".", "\\.")
                .Replace("[", "\\[")
                .Replace("]", "\\]")
                .Replace("(", "\\(")
                .Replace(")", "\\)")
                .Replace("*", "\\*")
                .Replace("?", ".?")
                .Replace("%r","\\r")
                .Replace("%n","\\n")
                .Replace("%d", "\\d*?")
                .Replace("%", ".*?");

            Regex 表达式 = new Regex(@"\\{(.+?):(.*?)\\}");
            MatchCollection 所有匹配 = 表达式.Matches(返回值);
            for (int i = 0; i < 所有匹配.Count; i++)
            {
                Match 匹配 = 所有匹配[i];
                返回值 = 返回值.Replace(匹配.Value, "(?<" + 匹配.Groups[1].Value + ">" + 匹配.Groups[2].Value + ")");
            }

            return 返回值;
        }
        /// <summary>
        /// 根据总记录数和一页显示记录计算出总页数
        /// </summary>
        /// <param name="总记录数">查询结果的总记录数</param>
        /// <param name="一页显示记录">一页显示的记录数</param>
        /// <returns>计算结果</returns>
        public static int 计算总页数(int 总记录数, int 一页显示记录)
        {
            if (总记录数 % 一页显示记录 == 0)
                return 总记录数 / 一页显示记录;
            else
                return 总记录数 / 一页显示记录 + 1;
        }
        /// <summary>
        /// 计算当前页的页码
        /// </summary>
        /// <param name="总页数">查询结果的总分页数</param>
        /// <param name="当前页">输入参数当前页的页码</param>
        /// <returns>计算结果</returns>
        public static int 计算当前页(int 总页数, int 当前页)
        {
            if (当前页 < 1)
                return 1;
            else if (总页数 == 0)
                return 1;
            else if (当前页 > 总页数)
                return 总页数;
            else
                return 当前页;
        }
        /// <summary>
        /// 计算一列数据的总和
        /// </summary>
        /// <param name="语句">计算总和的SQL语句</param>
        /// <returns>结果</returns>
        public static int 计算总和(SqlCommand 语句)
        {
            object o = 语句.ExecuteScalar();
            if (Convert.IsDBNull(o))
                return 0;
            else
                return Convert.ToInt32(o);
        }
        /// <summary>
        /// 将一个文件的大小转换为字符串的形式
        /// </summary>
        /// <param name="大小">文件大小的数值</param>
        /// <returns>文件大小</returns>
        public static String 计算文件大小(long 大小)
        {
            if (大小 < 1024)
                return 大小 + " B";
            else if (大小 < 1024 * 1024)
                return (大小 / 1024.00).ToString("F2") + " KB";
            else if (大小 < 1024 * 1024 * 1024)
                return (大小 / (1024 * 1024.00)).ToString("F2") + " MB";
            else
                return (大小 / (1024 * 1024 * 1024.00)).ToString("F2") + " GB";
        }
        /// <summary>
        /// 根据数量和总数量计算出所占的百分比
        /// </summary>
        /// <param name="总数量">所有数值的总值</param>
        /// <param name="数量">单项数值</param>
        /// <returns></returns>
        public static int 计算百分比(int 总数量, int 数量)
        {
            if (数量 == 0)
                return 0;
            return Convert.ToInt32((数量 / Convert.ToDouble(总数量)) * 100);
        }
        /// <summary>
        /// 计算该时间离现在过去多久
        /// </summary>
        /// <param name="时间">要计算的时间</param>
        /// <returns></returns>
        public static String 计算过去时间(DateTime 时间)
        {
            String 返回值;
            TimeSpan 间隔时间 = DateTime.Now - 时间;
            int 间隔秒 = (int)间隔时间.TotalSeconds;

            if (间隔秒 < 60)
                返回值 = 间隔秒 + "秒";
            else
            {
                int 分钟 = (int)间隔时间.TotalMinutes;
                if (分钟 < 60)
                    返回值 = 分钟 + "分钟"+间隔时间.Seconds+"秒";
                else
                {
                    int 小时 = (int)间隔时间.TotalHours;
                    if (小时 < 24)
                        返回值 = 小时 + "小时"+间隔时间.Minutes+"分";
                    else
                        返回值 = ((int)间隔时间.TotalDays) + "天"+间隔时间.Hours+"时";
                }
            }
            return 返回值;
        }
        /// <summary>
        /// 获取指定文件夹内的文件数量
        /// </summary>
        /// <param name="文件夹">文件夹对象</param>
        /// <returns></returns>
        public static int 获取文件数量(DirectoryInfo 文件夹)
        {
            int 返回值 = 文件夹.GetFiles().Length;

            DirectoryInfo[] 文件夹数组 = 文件夹.GetDirectories();
            for (int i = 0; i < 文件夹数组.Length; i++)
                返回值 += 获取文件数量(文件夹数组[i]);

            return 返回值;
        }
        /// <summary>
        /// 计算一个文件夹的大小
        /// </summary>
        /// <param name="文件夹">文件夹对象</param>
        /// <returns>文件夹的大小</returns>
        public static long 计算文件夹大小(DirectoryInfo 文件夹)
        {
            long 返回值 = 0;
            FileInfo[] FIS = 文件夹.GetFiles();
            for (int i = 0; i < FIS.Length; i++)
                返回值 += FIS[i].Length;

            DirectoryInfo[] 文件夹数组 = 文件夹.GetDirectories();
            for (int i = 0; i < 文件夹数组.Length; i++)
                返回值 += 计算文件夹大小(文件夹数组[i]);
            return 返回值;
        }
        /// <summary>
        /// 删除一个文件夹和它的子文件夹和文件
        /// </summary>
        /// <param name="文件夹">文件夹的所在位置</param>
        public static void 删除文件夹(String 文件夹)
        {
            删除文件夹(new DirectoryInfo(文件夹));
        }
        /// <summary>
        /// 删除一个文件夹和它的子文件夹和文件
        /// </summary>
        /// <param name="文件夹">文件夹对象</param>
        public static void 删除文件夹(DirectoryInfo 文件夹)
        {
            if (!文件夹.Exists)
                return;
            FileInfo[] FIS = 文件夹.GetFiles();
            for (int i = 0; i < FIS.Length; i++)
                FIS[i].Delete();

            DirectoryInfo[] DIS = 文件夹.GetDirectories();
            for (int i = 0; i < DIS.Length; i++)
                删除文件夹(DIS[i]);

            文件夹.Delete();
        }
        /// <summary>
        /// 验证该后缀是否为允许的后缀
        /// </summary>
        /// <param name="所有后缀">所有允许的文件后缀</param>
        /// <param name="后缀">需要验证的后缀</param>
        /// <returns>允许则为true,否则为false。</returns>
        public static bool 是否允许后缀(String 所有后缀, String 后缀)
        {
            String[] 后缀数组 = 所有后缀.Split(',');
            for (int i = 0; i < 后缀数组.Length; i++)
                if (后缀数组[i] == 后缀)
                    return true;
            return false;
        }
        /// <summary>
        /// 用MD5算法加密一个字符串
        /// </summary>
        /// <param name="字符串">需要加密的字符串</param>
        /// <returns>MD5加密结果</returns>
        public static String MD5加密(String 字符串)
        {
            return FormsAuthentication.HashPasswordForStoringInConfigFile(字符串, "MD5").ToUpper();
        }
        /// <summary>
        /// 将十六进制颜色转换为颜色对象
        /// </summary>
        /// <param name="颜色">十六进制颜色文字</param>
        /// <returns></returns>
        public static Color 十六进制颜色(String 颜色)
        {
            return Color.FromArgb(255, Convert.ToInt32(颜色.Substring(1, 2), 16),
                Convert.ToInt32(颜色.Substring(3, 2), 16),
                Convert.ToInt32(颜色.Substring(5, 2), 16));
        }
        /// <summary>
        /// 将UBB文本转换为相应的代码
        /// </summary>
        /// <param name="文本内容">文本的内容。</param>
        /// <param name="用户">当前访问的用户对象</param>
        /// <returns>转换结果</returns>
        public static String UBB转换(String 文本内容,Hashtable 用户)
        {
            文本内容 = 文本内容.Replace("\r\n", "<br/>");
            文本内容 = UBB转换_转换项(文本内容, "now", DateTime.Now.ToString());
            文本内容 = UBB转换_转换项(文本内容, "date", DateTime.Now.ToString("yyyy-MM-dd"));
            文本内容 = UBB转换_转换项(文本内容, "time", DateTime.Now.ToString("HH:mm:ss"));
            if (文本内容.IndexOf("(url=") != -1)
                文本内容 = UBB转换_URL(文本内容, "\\(url=(?<url>.*?)\\)(?<title>.+?)\\(/url\\)", 用户["标识"].ToString());
            if (文本内容.IndexOf("[url=") != -1)
                文本内容 = UBB转换_URL(文本内容, "\\[url=(?<url>.*?)\\](?<title>.+?)\\[/url\\]", 用户["标识"].ToString());
            if (文本内容.IndexOf("{url=") != -1)
                文本内容 = UBB转换_URL(文本内容, "\\{url=(?<url>.*?)\\}(?<title>.+?)\\{/url\\}", 用户["标识"].ToString());
            if (文本内容.IndexOf("(url)") != -1)
                文本内容 = UBB转换_URL_(文本内容, "\\(url\\)(?<url>.+?)\\(/url\\)", 用户["标识"].ToString());
            if (文本内容.IndexOf("[url]") != -1)
                文本内容 = UBB转换_URL_(文本内容, "\\[url\\](?<url>.+?)\\[/url\\]", 用户["标识"].ToString());
            if (文本内容.IndexOf("{url}") != -1)
                文本内容 = UBB转换_URL_(文本内容, "\\{url\\}(?<url>.+?)\\{/url\\}", 用户["标识"].ToString());
            if (文本内容.IndexOf("(img)") != -1)
                文本内容 = UBB转换_IMG(文本内容, "\\(img\\)(?<url>.+?)\\(/img\\)",用户["标识"].ToString());
            if (文本内容.IndexOf("[img]") != -1)
                文本内容 = UBB转换_IMG(文本内容, "\\[img\\](?<url>.+?)\\[/img\\]",用户["标识"].ToString());
            if (文本内容.IndexOf("{img}") != -1)
                文本内容 = UBB转换_IMG(文本内容, "\\{img\\}(?<url>.+?)\\{/img\\}",用户["标识"].ToString());
            文本内容 = UBB转换_转换项(文本内容, "br", "<br />");
            文本内容 = 替换标签(文本内容, "b", "b");
            文本内容 = 替换标签(文本内容, "i", "i");
            文本内容 = 替换标签(文本内容, "u", "u");
            文本内容 = 替换标签(文本内容, "s", "strike");
            文本内容 = 替换标签(文本内容, "big", "big");
            文本内容 = 替换标签(文本内容, "small", "small");
            if (文本内容.IndexOf("(font color=") != -1)
                文本内容 = UBB转换_FONT(文本内容, "\\(font color=(?<color>.+?)\\)(?<title>.+?)\\(/font\\)");
            if (文本内容.IndexOf("[font color=") != -1)
                文本内容 = UBB转换_FONT(文本内容, "\\[font color=(?<color>.+?)\\](?<title>.+?)\\[/font\\]");
            if (文本内容.IndexOf("{font color=") != -1)
                文本内容 = UBB转换_FONT(文本内容, "\\{font color=(?<color>.+?)\\}(?<title>.+?)\\{/font\\}");
            文本内容 = UBB转换_转换项(文本内容, "username", HttpUtility.HtmlEncode(用户["昵称"].ToString()));
            文本内容 = UBB转换_转换项(文本内容, "userid", 用户["ID"].ToString());
            文本内容 = UBB转换_转换项(文本内容, "usersid", 用户["标识"].ToString());
            文本内容 = UBB转换_转换项(文本内容, "userip", 用户["最后登录IP"].ToString());
            
            return 文本内容;
        }
        private static String 替换标签(String 内容, String 原值, String 新值)
        {
            if (内容.IndexOf("(" + 原值 + ")") != -1)
                内容 = _替换标签(内容, 原值, 新值, "(", ")");
            if (内容.IndexOf("[" + 原值 + "]") != -1)
                内容 = _替换标签(内容, 原值, 新值, "[", "]");
            if (内容.IndexOf("{" + 原值 + "}") != -1)
                内容 = _替换标签(内容, 原值, 新值, "{", "}");
            return 内容;
        }
        private static String _替换标签(String 内容, String 原值, String 新值, String 左括号, String 右括号)
        {
            Regex 表达式 = new Regex("\\" + 左括号 + 原值 + "\\" + 右括号 + "(.*?)\\" + 左括号 + "/" + 原值 + "\\" + 右括号);
            MatchCollection JGS = 表达式.Matches(内容);
            for (int i = 0; i < JGS.Count; i++)
            {
                Match JG = JGS[i];
                内容 = 内容.Replace(JG.Value, "<" + 新值 + ">" + JG.Groups[1].Value + "</" + 新值 + ">");
            }
            return 内容;
        }
        public static String 处理地址(String 地址, String 标识)
        {
            if ((!地址.StartsWith("http://",StringComparison.OrdinalIgnoreCase)) && 地址.IndexOf(".aspx",StringComparison.OrdinalIgnoreCase)!=-1)
                return 地址 + (地址.IndexOf('?') == -1 ? "?" : "&") + 程序.设置["标识名称"] + "=" + 标识;
            else
                return 地址;
        }
        private static String UBB转换_FONT(String 文本内容, String _表达式)
        {
            Regex 表达式 = new Regex(_表达式);
            MatchCollection JGS = 表达式.Matches(文本内容);
            for (int i = 0; i < JGS.Count; i++)
            {
                Match JG = JGS[i];
                文本内容 = 文本内容.Replace(JG.Value, "<font color=\"" +
                    JG.Groups["color"].Value + "\">" + JG.Groups["title"].Value + "</font>");
            }
            return 文本内容;
        }
        private static String UBB转换_IMG(String 文本内容, String _表达式,String 标识)
        {
            bool 是否WAP = HttpContext.Current.Response.ContentType == "text/vnd.wap.wml";
            Regex 表达式 = new Regex(_表达式);
            MatchCollection JGS = 表达式.Matches(文本内容);
            for (int i = 0; i < JGS.Count; i++)
            {
                Match JG = JGS[i];
                String 地址 = JG.Groups["url"].Value;
                地址=地址.Replace("~/", 程序.安装位置).Replace("&amp;", "&");
                文本内容 = 文本内容.Replace(JG.Value, "<img src=\"" +
                    HttpUtility.HtmlEncode(地址) + "\"" +
                    常用.获取图片宽度高度("UBB")+
                    " alt=\"图片\" /><br/>" +
                    "<a href=\"" + HttpUtility.HtmlEncode(常用.处理地址(程序.安装位置 + (是否WAP?"":"3G_") +"ImageZoom.aspx?type=small&img="+HttpUtility.UrlEncode(地址)+"&rurl=" + HttpUtility.UrlEncode(HttpContext.Current.Request.Url.ToString()), 标识)) +
                    "\">小图</a> " +
                    "<a href=\"" + HttpUtility.HtmlEncode(常用.处理地址(程序.安装位置 + (是否WAP ? "" : "3G_") + "ImageZoom.aspx?type=middle&img=" + HttpUtility.UrlEncode(地址) + "&rurl=" + HttpUtility.UrlEncode(HttpContext.Current.Request.Url.ToString()), 标识)) +
                    "\">中图</a> " +
                    "<a href=\"" + HttpUtility.HtmlEncode(常用.处理地址(程序.安装位置 + (是否WAP ? "" : "3G_") + "ImageZoom.aspx?type=big&img=" + HttpUtility.UrlEncode(地址) + "&rurl=" + HttpUtility.UrlEncode(HttpContext.Current.Request.Url.ToString()), 标识)) +
                    "\">大图</a> " +
                    "<a href=\"" + HttpUtility.HtmlEncode(常用.处理地址(程序.安装位置 + (是否WAP ? "" : "3G_") + "ImageZoom.aspx?type=null&img=" + HttpUtility.UrlEncode(地址) + "&rurl=" + HttpUtility.UrlEncode(HttpContext.Current.Request.Url.ToString()), 标识)) +
                    "\">自定</a><br/>");
            }
            return 文本内容;
        }
        private static String UBB转换_URL_(String 文本内容, String _表达式, String 标识)
        {
            Regex 表达式 = new Regex(_表达式);
            MatchCollection JGS = 表达式.Matches(文本内容);
            for (int i = 0; i < JGS.Count; i++)
            {
                Match JG = JGS[i];
                String 地址 = 处理地址(JG.Groups["url"].Value.Replace("&amp;", "&"), 标识);
                文本内容 = 文本内容.Replace(JG.Value, "<a href=\"" +
                    HttpUtility.HtmlEncode(地址.Replace("~/", 程序.安装位置)) +
                    "\">" + HttpUtility.HtmlEncode(地址.Replace("~/", 程序.安装位置)) + "</a>");
            }
            return 文本内容;
        }
        private static String UBB转换_URL(String 文本内容,String _表达式,String 标识)
        {
            Regex 表达式 = new Regex(_表达式);
            MatchCollection JGS = 表达式.Matches(文本内容);
            for (int i = 0; i < JGS.Count; i++)
            {
                Match JG = JGS[i];
                文本内容 = 文本内容.Replace(JG.Value, "<a href=\"" +
                    HttpUtility.HtmlEncode(处理地址(JG.Groups["url"].Value.Replace("~/", 程序.安装位置).Replace("&amp;", "&"), 标识)) +
                    "\">" + HttpUtility.HtmlEncode(JG.Groups["title"].Value) + "</a>");
            }
            return 文本内容;
        }
        private static String UBB转换_转换项(String 文本内容,String 项名称, String 项值)
        {
            if (文本内容.IndexOf("(" + 项名称 + ")") != -1)
                文本内容 = 文本内容.Replace("(" + 项名称 + ")", 项值);
            if (文本内容.IndexOf("[" + 项名称 + "]") != -1)
                文本内容 = 文本内容.Replace("[" + 项名称 + "]", 项值);
            if (文本内容.IndexOf("{" + 项名称 + "}") != -1)
                文本内容 = 文本内容.Replace("{" + 项名称 + "}", 项值);
            return 文本内容;
        }
        /// <summary>
        /// 将UBB字符转换为相应的转义字符
        /// </summary>
        /// <param name="文本内容">UBB文本内容</param>
        /// <returns></returns>
        public static String 替换UBB字符(String 文本内容)
        {
            return 文本内容.Replace("#", "#;")
                .Replace("(", "##1")
                .Replace(")", "##2")
                .Replace("[", "##3")
                .Replace("]", "##4")
                .Replace("{", "##5")
                .Replace("}", "##6");
        }
        /// <summary>
        /// 将转义结果替换回原文本
        /// </summary>
        /// <param name="文本内容">转换结果内容</param>
        /// <returns></returns>
        public static String 反向替换UBB字符(String 文本内容)
        {
            return 文本内容.Replace("##1", "(")
                .Replace("##2", ")")
                .Replace("##3", "[")
                .Replace("##4", "]")
                .Replace("##5", "{")
                .Replace("##6", "}")
                .Replace("#;", "#");
        }
        /// <summary>
        /// 将网络文件下载到服务器
        /// </summary>
        /// <param name="网络地址">文件的网络地址</param>
        /// <param name="文件位置">文件保存到的位置</param>
        public static void 下载文件(String 网络地址, String 文件位置)
        {
            HttpWebRequest 请求 = (HttpWebRequest)WebRequest.Create(网络地址);
            请求.Method = "GET";
            HttpWebResponse 响应 = (HttpWebResponse)请求.GetResponse();
            Stream 响应流 = 响应.GetResponseStream();

            FileStream 文件流 = File.Open(文件位置, FileMode.Create,FileAccess.Write);
            Byte[] 缓冲字节 = new byte[1024 * 6];
            int 读取数 = 0;
            while ((读取数 = 响应流.Read(缓冲字节, 0, 1024 * 6)) > 0)
                文件流.Write(缓冲字节, 0, 读取数);
            文件流.Close();
            响应流.Close();
            响应.Close();
        }
        /// <summary>
        /// 将本地文件保存到服务器
        /// </summary>
        /// <param name="HF">本地文件对象</param>
        /// <param name="文件位置">服务器文件位置</param>
        public static void 上传文件(HttpPostedFile HF, String 文件位置)
        {
            Stream 上传流 = HF.InputStream;

            FileStream 文件流 = File.Open(文件位置, FileMode.Create, FileAccess.Write);
            Byte[] 缓冲字节 = new byte[1024 * 6];
            int 读取数=0;
            while ((读取数 = 上传流.Read(缓冲字节, 0, 1024 * 6)) > 0)
                文件流.Write(缓冲字节, 0, 读取数);
            文件流.Close();
            上传流.Close();
        }
        /// <summary>
        /// 将图片缩放至指定宽度和高度
        /// </summary>
        /// <param name="图片位置">要缩放的图片文件</param>
        /// <param name="宽度">要缩放的图片宽度</param>
        /// <param name="高度">要缩放的图片高度</param>
        public static void 缩放图片(String 图片位置, int 宽度, int 高度)
        {
            Bitmap 图片 = new Bitmap(图片位置);
            Bitmap 新图片 = new Bitmap(图片, 宽度, 高度);
            
            新图片.Save(图片位置);

            图片.Dispose();
            新图片.Dispose();
        }
        /// <summary>
        /// 获取某个栏目的名称
        /// </summary>
        /// <param name="ID">栏目的ID</param>
        /// <returns></returns>
        public static String 获取栏目名称(int ID)
        {
            DataSet 内容栏目 = (DataSet)HttpContext.Current.Application["UUN_UUN3G_NeiRongLanMu"];
            String 返回值 = "";
            for (int i = 0; i < 内容栏目.Tables[0].Rows.Count; i++)
            {
                DataRow 行 = 内容栏目.Tables[0].Rows[i];
                if (Convert.ToInt32(行["ID"]) == ID)
                    返回值 = Convert.ToString(行["栏目名称"]);
            }
            return 返回值;
        }
        /// <summary>
        /// 截取指定长度的字符串，全角字符算两个字符。
        /// </summary>
        /// <param name="字符串">要截取的字符串</param>
        /// <param name="长度">要截取的长度</param>
        /// <returns></returns>
        public static String 截取字符串(String 字符串, int 长度)
        {
            if (长度 < 1)
                return 字符串;
            byte[] 字节数组 = Encoding.UTF8.GetBytes(字符串);
            if (字节数组.Length > 长度)
            {
                String 返回值 = "";
                for (int i = 0; i < 字符串.Length; i++)
                {
                    byte[] 临时字节 = Encoding.UTF8.GetBytes(返回值);
                    if (临时字节.Length < 长度)
                        返回值 += 字符串.Substring(i, 1);
                    else
                        break;
                }
                return 返回值;
            }
            else
                return 字符串;
        }
        /// <summary>
        /// 截取最长长度字符串，长度以字为单位
        /// </summary>
        /// <param name="字符串">要截取的字符串。</param>
        /// <param name="长度">要截取的长度。</param>
        /// <returns></returns>
        public static String 截取最长字符串(String 字符串, int 长度)
        {
            if (字符串.Length > 长度)
                return 字符串.Substring(0, 长度);
            else
                return 字符串;
        }
        /// <summary>
        /// 将对象保存为文件
        /// </summary>
        /// <param name="对象">对象数据</param>
        /// <param name="保存位置">对象保存到的位置</param>
        public static void 保存对象(object 对象, String 保存位置)
        {
            BinaryFormatter 序列化 = new BinaryFormatter();
            FileStream FS=new FileStream(保存位置,FileMode.Create,FileAccess.Write);
            序列化.Serialize(FS, 对象);
            FS.Close();
        }
        /// <summary>
        /// 将文件读取为对象
        /// </summary>
        /// <param name="位置">对象的位置</param>
        /// <returns></returns>
        public static object 读取对象(String 位置)
        {
            BinaryFormatter 序列化 = new BinaryFormatter();
            FileStream FS = new FileStream(位置, FileMode.Open, FileAccess.Read);
            object 返回值 = 序列化.Deserialize(FS);
            FS.Close();
            return 返回值;
        }
    }
}