C#工具类--Utils备忘

系统管理员 2024-03-24 11:19 40阅读 0赞

## C\#工具类–Utils ##

using System;  
    using System.Collections.Generic;  
    using System.Linq;  
    using System.Web;  
    using System.IO;  
    using System.Net;  
    using System.Text;  
    using System.Runtime.Serialization;  
    using System.Runtime.Serialization.Json;  
    using System.Text.RegularExpressions;  
    using HtmlAgilityPack;  
    using System.Collections;  
    using System.Web.UI;  
    using System.Globalization;  
      
    namespace Common  
    {
          
        /// <summary>  
        /// 常用工具类  
        /// </summary>  
        public class Utils  
        {
          
            /// <summary>  
            /// 读取本地磁盘文件内容  
            /// </summary>  
            /// <param name="url">文件路径</param>  
            /// <returns></returns>  
            public static string GetFileSource(string path)  
            {
          
                try  
                {
          
                    using (StreamReader myFile = new StreamReader(System.Web.HttpContext.Current.Server.MapPath(path), Encoding.Default))  
                    {
         return myFile.ReadToEnd(); }  
                }  
                catch {
         return ""; }  
            }  
      
      
            /// <summary>  
            /// 生成Json格式  
            /// 首先应添加对System.ServiceModel.Web,System.Runtime.Serialization的引用，  
            /// 然后添加System.Runtime.Serialization.Json命名空间  
            /// </summary>  
            /// <typeparam name="T"></typeparam>  
            /// <param name="obj"></param>  
            /// <returns></returns>  
            public static string GetJson<T>(T obj)  
            {
          
                DataContractJsonSerializer json = new DataContractJsonSerializer(obj.GetType());  
                using (MemoryStream stream = new MemoryStream())  
                {
          
                    json.WriteObject(stream, obj);  
                    string szJson = Encoding.UTF8.GetString(stream.ToArray()); return szJson;  
                }  
            }  
            /// <summary>  
            /// 获取Json的Model  
            /// </summary>  
            /// <typeparam name="T"></typeparam>  
            /// <param name="szJson"></param>  
            /// <returns></returns>  
            public static T ParseFromJson<T>(string szJson)  
            {
          
                T obj = Activator.CreateInstance<T>();  
                using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(szJson)))  
                {
          
                    DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());  
                    return (T)serializer.ReadObject(ms);  
                }  
            }  
      
            /// <summary>  
            /// 返回文件是否存在  
            /// </summary>  
            /// <param name="filename">文件名</param>  
            /// <returns>是否存在</returns>  
            public static bool FileExists(string filename)  
            {
          
                return File.Exists(filename);  
            }  
      
            /// <summary>  
            /// 过滤字符串  
            /// </summary>  
            /// <param name="str"></param>  
            /// <returns></returns>  
            public static string FileterStr(string str)  
            {
          
                if (!string.IsNullOrWhiteSpace(str))  
                {
          
                    str = Regex.Replace(str, @"(<script>)", "<script>", System.Text.RegularExpressions.RegexOptions.IgnoreCase);  
                    str = Regex.Replace(str, @"(</script>)", "</script>", System.Text.RegularExpressions.RegexOptions.IgnoreCase);  
                    str = Regex.Replace(str, @"( ){4,}", "    ", System.Text.RegularExpressions.RegexOptions.IgnoreCase);  
                    str = Regex.Replace(str, @"(<br>){1,}|(<br/>){1,}", "<br>", System.Text.RegularExpressions.RegexOptions.IgnoreCase);  
                    str = Regex.Replace(str, @"(<br>){1,}", "<br>", System.Text.RegularExpressions.RegexOptions.IgnoreCase);  
                }  
                else  
                {
         str = ""; }  
                return str;  
            }  
      
      
            /// <summary>  
            /// 过滤Script字符串  
            /// </summary>  
            /// <param name="str"></param>  
            /// <returns></returns>  
            public static string FileterScript(string str)  
            {
          
                if (!string.IsNullOrWhiteSpace(str))  
                {
          
                    str = Regex.Replace(str, @"(<script>)", "<script>", System.Text.RegularExpressions.RegexOptions.IgnoreCase);  
                    str = Regex.Replace(str, @"(</script>)", "</script>", System.Text.RegularExpressions.RegexOptions.IgnoreCase);  
                }  
                else  
                {
         str = ""; }  
                return str;  
            }  
      
            /// <summary>  
            /// 获得当前绝对路径  
            /// </summary>  
            /// <param name="strPath">指定的路径</param>  
            /// <returns>绝对路径</returns>  
            public static string GetMapPath(string strPath)  
            {
          
                if (HttpContext.Current != null)  
                {
          
                    return HttpContext.Current.Server.MapPath(strPath);  
                }  
                else //非web程序引用  
                {
          
                    strPath = strPath.Replace("/", "\\");  
                    if (strPath.StartsWith("\\"))  
                    {
          
                        strPath = strPath.Substring(strPath.IndexOf('\\', 1)).TrimStart('\\');  
                    }  
                    return System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, strPath);  
                }  
            }  
      
            /// <summary>  
            /// 得到网站的真实路径  
            /// </summary>  
            /// <returns></returns>  
            public static string GetTrueWebPath()  
            {
          
                string webPath = HttpContext.Current.Request.Path;  
                if (webPath.LastIndexOf("/") != webPath.IndexOf("/"))  
                    webPath = webPath.Substring(webPath.IndexOf("/"), webPath.LastIndexOf("/") + 1);  
                else  
                    webPath = "/";  
      
                return webPath;  
            }  
      
            /// <summary>  
            /// 获取站点根目录URL  
            /// </summary>  
            /// <returns></returns>  
            public static string GetRootUrl(string forumPath)  
            {
          
                int port = HttpContext.Current.Request.Url.Port;  
                return string.Format("{0}://{1}{2}{3}",  
                                     HttpContext.Current.Request.Url.Scheme,  
                                     HttpContext.Current.Request.Url.Host.ToString(),  
                                     (port == 80 || port == 0) ? "" : ":" + port,  
                                     forumPath);  
            }  
      
            /// <summary>  
            /// 验证文件名  
            /// </summary>  
            private static readonly char[] InvalidFileNameChars = new[]  
                                                                      {
          
                                                                          '"',  
                                                                          '<',  
                                                                          '>',  
                                                                          '|',  
                                                                          '\0',  
                                                                          '\u0001',  
                                                                          '\u0002',  
                                                                          '\u0003',  
                                                                          '\u0004',  
                                                                          '\u0005',  
                                                                          '\u0006',  
                                                                          '\a',  
                                                                          '\b',  
                                                                          '\t',  
                                                                          '\n',  
                                                                          '\v',  
                                                                          '\f',  
                                                                          '\r',  
                                                                          '\u000e',  
                                                                          '\u000f',  
                                                                          '\u0010',  
                                                                          '\u0011',  
                                                                          '\u0012',  
                                                                          '\u0013',  
                                                                          '\u0014',  
                                                                          '\u0015',  
                                                                          '\u0016',  
                                                                          '\u0017',  
                                                                          '\u0018',  
                                                                          '\u0019',  
                                                                          '\u001a',  
                                                                          '\u001b',  
                                                                          '\u001c',  
                                                                          '\u001d',  
                                                                          '\u001e',  
                                                                          '\u001f',  
                                                                          ':',  
                                                                          '*',  
                                                                          '?',  
                                                                          '\\',  
                                                                          '/'  
                                                                      };  
      
            public static string CleanInvalidFileName(string fileName)  
            {
          
                fileName = fileName + "";  
                fileName = InvalidFileNameChars.Aggregate(fileName, (current, c) => current.Replace(c + "", ""));  
      
                if (fileName.Length > 1)  
                    if (fileName[0] == '.')  
                        fileName = "dot" + fileName.TrimStart('.');  
      
                return fileName;  
            }  
      
            /// <summary>  
            /// 将远程图片保存到服务器  
            /// </summary>  
            /// <param name="remotePath"></param>  
            /// <param name="filePath"></param>  
            public static string DownLoadImg(string url, string folderPath, bool isoldname = false)  
            {
          
                try  
                {
          
                    string fileName = "";  
                    fileName = url.Substring(url.LastIndexOf("/") + 1);  
                    if (fileName.IndexOf("?") > -1)  
                    {
          
                        fileName = fileName.Substring(0, fileName.IndexOf("?"));  
                    }  
                    fileName = CleanInvalidFileName(fileName);  
                    if (!isoldname)  
                    {
          
                        string extension = fileName.Split('.')[1];  
                        // 生成随机文件名  
                        Random random = new Random(DateTime.Now.Millisecond);  
                        fileName = DateTime.Now.ToString("yyyyMMddHHmmss_ffff", DateTimeFormatInfo.InvariantInfo) + "." + extension;  
                    }  
                    var fileFolder = HttpContext.Current.Server.MapPath(folderPath);  
                    DownloadImage(url, fileFolder + fileName);  
                    return folderPath + fileName;  
                }  
                catch  
                {
          
                    return "";  
                }  
            }  
      
            /// <summary>  
            /// 将远程图片保存到服务器  
            /// </summary>  
            /// <param name="remotePath"></param>  
            /// <param name="filePath"></param>  
            public static void DownloadImage(string remotePath, string filePath)  
            {
          
                WebClient w = new WebClient();  
                try  
                {
          
                    w.DownloadFile(remotePath, filePath);  
                }  
                finally  
                {
          
                    w.Dispose();  
                }  
            }  
      
            /// <summary>  
            /// 把内容中的图片下载到本地  
            /// </summary>  
            /// <param name="htmlContent"></param>  
            /// <returns></returns>  
            public static string DownloadImages(string htmlContent, string folderPath,string webUrl)  
            {
          
                string newContent = htmlContent;  
                //实例化HtmlAgilityPack.HtmlDocument对象  
                HtmlDocument doc = new HtmlDocument();  
                //载入HTML  
                doc.LoadHtml(htmlContent);  
                var imgs = doc.DocumentNode.SelectNodes("//img");  
                if (imgs != null && imgs.Count > 0)  
                {
          
                    foreach (HtmlNode child in imgs)  
                    {
          
                        if (child.Attributes["src"] == null)  
                            continue;  
      
                        string imgurl = child.Attributes["src"].Value;  
      
                        if (imgurl.IndexOf(webUrl) > -1 || imgurl.IndexOf("http://") == -1)  
                            continue;  
      
                        string newimgurl = DownLoadImg(imgurl, folderPath);  
                        if (newimgurl != "")  
                        {
          
                            newContent=newContent.Replace(imgurl, webUrl + newimgurl);  
                        }  
                    }  
                }  
                return newContent;  
            }  
      
            /// <summary>  
            /// 刷新图片地址,加上指定url前缀  
            /// </summary>  
            /// <param name="htmlContent"></param>  
            /// <returns></returns>  
            public static string RefreshImageUrl(string htmlContent, string webUrl)  
            {
          
                string newContent = htmlContent;  
                HtmlDocument doc = new HtmlDocument();  
                doc.LoadHtml(htmlContent);  
                var imgs = doc.DocumentNode.SelectNodes("//img");  
                if (imgs != null && imgs.Count > 0)  
                {
          
                    foreach (HtmlNode child in imgs)  
                    {
          
                        if (child.Attributes["src"] == null)  
                            continue;  
      
                        string imgurl = child.Attributes["src"].Value;  
      
                        if (imgurl.IndexOf(webUrl) > -1 || imgurl.IndexOf("http://") > -1)  
                            continue;  
      
                        string newimgurl = webUrl + imgurl;  
                        newContent = newContent.Replace(imgurl, newimgurl);  
                    }  
                }  
                return newContent;  
            }  
      
      
      
            /// <summary>  
            /// 获得当前页面客户端的IP  
            /// </summary>  
            /// <returns>当前页面客户端的IP</returns>  
            public static string GetIP()  
            {
          
                string result = HttpContext.Current.Request.ServerVariables["REMOTE_ADDR"];  
                if (string.IsNullOrEmpty(result))  
                    result = HttpContext.Current.Request.ServerVariables["HTTP_X_FORWARDED_FOR"];  
      
                if (string.IsNullOrEmpty(result))  
                    result = HttpContext.Current.Request.UserHostAddress;  
      
                if (string.IsNullOrEmpty(result) || !IsIP(result))  
                    return "127.0.0.1";  
      
                return result;  
            }  
      
            /// <summary>  
            /// 是否为ip  
            /// </summary>  
            /// <param name="ip"></param>  
            /// <returns></returns>  
            public static bool IsIP(string ip)  
            {
          
                return Regex.IsMatch(ip, @"^((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)$");  
            }  
      
      
            private static Regex RegexBr = new Regex(@"(\r\n)", RegexOptions.IgnoreCase);  
      
            /// <summary>  
            /// 清除给定字符串中的回车及换行符  
            /// </summary>  
            /// <param name="str">要清除的字符串</param>  
            /// <returns>清除后返回的字符串</returns>  
            public static string ClearBR(string str)  
            {
          
                Match m = null;  
      
                for (m = RegexBr.Match(str); m.Success; m = m.NextMatch())  
                {
          
                    str = str.Replace(m.Groups[0].ToString(), "");  
                }  
                return str;  
            }  
      
      
            public static Regex regImg = new Regex(@"<img\b[^<>]*?\bsrc[\s\t\r\n]*=[\s\t\r\n]*[""']?[\s\t\r\n]*(?<imgUrl>[^\s\t\r\n""'<>]*)[^<>]*?/?[\s\t\r\n]*>", RegexOptions.IgnoreCase);  
              
            /// <summary>  
            /// 获得指定内容中的第一张图片  
            /// </summary>  
            /// <returns></returns>  
            public static string GetImg(string str)  
            {
          
                Match m = regImg.Match(str);  
                if (m.Success)  
                    return m.Groups["imgUrl"].ToString();  
      
                return "";  
            }  
      
            /// <summary>  
            /// 获得指定内容中的所有图片  
            /// </summary>  
            /// <returns></returns>  
            public static string GetImgs(string str)  
            {
          
                string strTemp = "";  
                MatchCollection matches = regImg.Matches(str);  
                foreach (Match match in matches)  
                {
          
                    strTemp += "'" + match.Groups["imgUrl"].Value + "',";  
                }  
      
                return strTemp.Trim(',');  
            }  
      
            /// <summary>  
            /// 删除指定内容中的所有图片  
            /// </summary>  
            /// <returns></returns>  
            public static string ClearImgs(string str)  
            {
          
                Match m = null;  
      
                for (m = regImg.Match(str); m.Success; m = m.NextMatch())  
                {
          
                    str = str.Replace(m.Groups[0].ToString(), "");  
                }  
                return str;  
            }  
      
            /// <summary>  
            /// 根据Url获得源文件内容  
            /// </summary>  
            /// <param name="url">合法的Url地址</param>  
            /// <returns></returns>  
            public static string GetSourceTextByUrl(string url)  
            {
          
                try  
                {
          
                    WebRequest request = WebRequest.Create(url);  
                    request.Timeout = 20000;//20秒超时  
                    WebResponse response = request.GetResponse();  
      
                    Stream resStream = response.GetResponseStream();  
                    StreamReader sr = new StreamReader(resStream);  
                    return sr.ReadToEnd();  
                }  
                catch {
         return ""; }  
            }  
      
            /// <summary>  
            /// 访问指定url  
            /// </summary>  
            /// <param name="url">合法的Url地址</param>  
            /// <returns></returns>  
            public static void AccessUrl(string url)  
            {
          
                try  
                {
          
                    WebRequest request = WebRequest.Create(url);  
                    request.Timeout = 20000;//20秒超时  
                    WebResponse response = request.GetResponse();  
                }  
                catch {
         }  
            }  
      
      
            /// <summary>  
            /// 移除Html标记  
            /// </summary>  
            /// <param name="content"></param>  
            /// <returns></returns>  
            public static string RemoveHtml(string content)  
            {
          
                return Regex.Replace(content, @"<[^>]*>", string.Empty, RegexOptions.IgnoreCase);  
            }  
      
            /// <summary>  
            /// 过滤HTML中的不安全标签  
            /// </summary>  
            /// <param name="content"></param>  
            /// <returns></returns>  
            public static string RemoveUnsafeHtml(string content)  
            {
          
                content = Regex.Replace(content, @"(\<|\s+)o([a-z]+\s?=)", "$1$2", RegexOptions.IgnoreCase);  
                content = Regex.Replace(content, @"(script|frame|form|meta|behavior|style)([\s|:|>])+", "$1.$2", RegexOptions.IgnoreCase);  
                return content;  
            }  
      
            /// <summary>  
            /// 从HTML中获取文本,保留br,p,img  
            /// </summary>  
            /// <param name="HTML"></param>  
            /// <returns></returns>  
            public static string GetTextFromHTML(string HTML)  
            {
          
                System.Text.RegularExpressions.Regex regEx = new System.Text.RegularExpressions.Regex(@"</?(?!br|/?p|img)[^>]*>", System.Text.RegularExpressions.RegexOptions.IgnoreCase);  
      
                return regEx.Replace(HTML, "");  
            }  
      
            /// <summary>  
            /// 根据字符串获取枚举值  
            /// </summary>  
            /// <typeparam name="T">枚举类型</typeparam>  
            /// <param name="value">字符串枚举值</param>  
            /// <param name="defValue">缺省值</param>  
            /// <returns></returns>  
            public static T GetEnum<T>(string value, T defValue)  
            {
          
                try  
                {
          
                    return (T)Enum.Parse(typeof(T), value, true);  
                }  
                catch (ArgumentException)  
                {
          
                    return defValue;  
                }  
            }  
      
            /// <summary>  
            /// 删除字符串尾部的回车/换行/空格  
            /// </summary>  
            /// <param name="str"></param>  
            /// <returns></returns>  
            public static string RTrim(string str)  
            {
          
                for (int i = str.Length; i >= 0; i--)  
                {
          
                    if (str[i].Equals(" ") || str[i].Equals("\r") || str[i].Equals("\n"))  
                    {
          
                        str.Remove(i, 1);  
                    }  
                }  
                return str;  
            }  
      
            /// <summary>  
            /// 从字符串的指定位置截取指定长度的子字符串  
            /// </summary>  
            /// <param name="str">原字符串</param>  
            /// <param name="startIndex">子字符串的起始位置</param>  
            /// <param name="length">子字符串的长度</param>  
            /// <returns>子字符串</returns>  
            public static string CutString(string str, int startIndex, int length)  
            {
          
                if (startIndex >= 0)  
                {
          
                    if (length < 0)  
                    {
          
                        length = length * -1;  
                        if (startIndex - length < 0)  
                        {
          
                            length = startIndex;  
                            startIndex = 0;  
                        }  
                        else  
                            startIndex = startIndex - length;  
                    }  
      
                    if (startIndex > str.Length)  
                        return "";  
                }  
                else  
                {
          
                    if (length < 0)  
                        return "";  
                    else  
                    {
          
                        if (length + startIndex > 0)  
                        {
          
                            length = length + startIndex;  
                            startIndex = 0;  
                        }  
                        else  
                            return "";  
                    }  
                }  
      
                if (str.Length - startIndex < length)  
                    length = str.Length - startIndex;  
      
                return str.Substring(startIndex, length);  
            }  
      
            /// <summary>  
            /// 从字符串的指定位置开始截取到字符串结尾的了符串  
            /// </summary>  
            /// <param name="str">原字符串</param>  
            /// <param name="startIndex">子字符串的起始位置</param>  
            /// <returns>子字符串</returns>  
            public static string CutString(string str, int startIndex)  
            {
          
                return CutString(str, startIndex, str.Length);  
            }  
      
            /// <summary>  
            /// 将对象转换为Int32类型  
            /// </summary>  
            /// <param name="strValue">要转换的字符串</param>  
            /// <param name="defValue">缺省值</param>  
            /// <returns>转换后的int类型结果</returns>  
            public static int ObjectToInt(object expression)  
            {
          
                return ObjectToInt(expression, 0);  
            }  
      
            /// <summary>  
            /// 将对象转换为Int32类型  
            /// </summary>  
            /// <param name="strValue">要转换的字符串</param>  
            /// <param name="defValue">缺省值</param>  
            /// <returns>转换后的int类型结果</returns>  
            public static int ObjectToInt(object expression, int defValue)  
            {
          
                if (expression != null)  
                    return StrToInt(expression.ToString(), defValue);  
      
                return defValue;  
            }  
      
            /// <summary>  
            /// 将对象转换为Int32类型,转换失败返回0  
            /// </summary>  
            /// <param name="str">要转换的字符串</param>  
            /// <returns>转换后的int类型结果</returns>  
            public static int StrToInt(string str)  
            {
          
                return StrToInt(str, 0);  
            }  
      
            /// <summary>  
            /// 将对象转换为Int32类型  
            /// </summary>  
            /// <param name="str">要转换的字符串</param>  
            /// <param name="defValue">缺省值</param>  
            /// <returns>转换后的int类型结果</returns>  
            public static int StrToInt(string str, int defValue)  
            {
          
                if (string.IsNullOrEmpty(str) || str.Trim().Length >= 11 || !Regex.IsMatch(str.Trim(), @"^([-]|[0-9])[0-9]*(\.\w*)?$"))  
                    return defValue;  
      
                int rv;  
                if (Int32.TryParse(str, out rv))  
                    return rv;  
      
                return Convert.ToInt32(StrToFloat(str, defValue));  
            }  
      
            /// <summary>  
            /// string型转换为float型  
            /// </summary>  
            /// <param name="strValue">要转换的字符串</param>  
            /// <param name="defValue">缺省值</param>  
            /// <returns>转换后的int类型结果</returns>  
            public static float StrToFloat(string strValue, float defValue)  
            {
          
                if ((strValue == null) || (strValue.Length > 10))  
                    return defValue;  
      
                float intValue = defValue;  
                if (strValue != null)  
                {
          
                    bool IsFloat = Regex.IsMatch(strValue, @"^([-]|[0-9])[0-9]*(\.\w*)?$");  
                    if (IsFloat)  
                        float.TryParse(strValue, out intValue);  
                }  
                return intValue;  
            }  
      
            /// <summary>  
            /// 获得指定数量的符号字符串  
            /// </summary>  
            /// <param name="count"></param>  
            /// <param name="str"></param>  
            /// <returns></returns>  
            public static string GetSpace(int count, string str)  
            {
          
                string tmp = "";  
                for (int i = 1; i < count; i++)  
                {
          
                    tmp += str;  
                }  
                return tmp;  
            }  
      
            /// <summary>  
            /// 清除字符串数组中的重复项  
            /// </summary>  
            /// <param name="strArray">字符串数组</param>  
            /// <param name="maxElementLength">字符串数组中单个元素的最大长度</param>  
            /// <returns></returns>  
            public static string[] DistinctStringArray(string[] strArray, int maxElementLength)  
            {
          
                Hashtable h = new Hashtable();  
      
                foreach (string s in strArray)  
                {
          
                    string k = s;  
                    if (maxElementLength > 0 && k.Length > maxElementLength)  
                    {
          
                        k = k.Substring(0, maxElementLength);  
                    }  
                    h[k.Trim()] = s;  
                }  
      
                string[] result = new string[h.Count];  
      
                h.Keys.CopyTo(result, 0);  
      
                return result;  
            }  
      
            /// <summary>  
            /// 清除字符串数组中的重复项  
            /// </summary>  
            /// <param name="strArray">字符串数组</param>  
            /// <returns></returns>  
            public static string[] DistinctStringArray(string[] strArray)  
            {
          
                return DistinctStringArray(strArray, 0);  
            }  
      
            /// <summary>  
            /// 获取字符串a在b中出现的次数  
            /// </summary>  
            public static int RegexCount(string regstr, string str)  
            {
          
                Regex r = new Regex(regstr, RegexOptions.Singleline | RegexOptions.IgnoreCase);  
                MatchCollection m = r.Matches(str);  
                return m.Count;  
            }  
      
            /// <summary>  
            /// 消除无效的XML编码字符  
            /// </summary>  
            public static string CleanInvalidXmlChars(string text)  
            {
          
                // From xml spec valid chars:  
                // #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]      
                // any Unicode character, excluding the surrogate blocks, FFFE, and FFFF.  
                string re = @"[^\x09\x0A\x0D\x20-\xD7FF\xE000-\xFFFD\x10000-x10FFFF]";  
                return Regex.Replace(text, re, "");  
            }  
      
            /// <summary>  
            /// web页转换为静态html  
            /// </summary>  
            public static void CreateHtml(string url, string outpath)  
            {
          
                FileStream fs;  
                if (File.Exists(outpath))  
                {
          
                    File.Delete(outpath);  
                    fs = File.Create(outpath);  
                }  
                else  
                {
          
                    fs = File.Create(outpath);  
                }  
                byte[] bt = Encoding.UTF8.GetBytes(GetSourceTextByUrl(url));  
                fs.Write(bt, 0, bt.Length);  
                fs.Close();  
            }  
      
            /// <summary>  
            /// 删除html  
            /// </summary>  
            public static void DeleteHtml(string path)  
            {
          
                if (File.Exists(path))  
                {
          
                    File.Delete(path);  
                }  
            }  
      
            //创建文件夹  
            public static void CreateFolder(string FolderPath)  
            {
          
                if (!System.IO.Directory.Exists(FolderPath)) System.IO.Directory.CreateDirectory(FolderPath);  
            }  
        }  
    }