C# 字符串操作类

C# 字符串操作类

 

view source

print?

0001	using System;

0002	using System.Collections.Generic;

0003	using System.Text;

0004	using System.Collections;

0005	using System.Text.RegularExpressions;

0006	using System.Security.Cryptography;

0007

/**/

0008	////////////////////////////////////////////////////

0009	///功能：字符文本操作类

0010

///

0011

///

0012	////////////////////////////////////////////////////

0013	namespace XHW

0014

{

0015	/// <summary>

0016	/// 字符文本操作类

0017	/// </summary>

0018	public class StringHelper

0019

{

0020	public static bool IsContains(string[] strs, string value)

0021

{

0022	if (strs == null)

0023

{

0024	return false;

0025

}

0026

0027	foreach (string str in strs)

0028

{

0029	if (str == value)

0030

{

0031	return true;

0032

}

0033

}

0034

0035	return false;

0036

}

0037

0038

0039

0040	#region 字符串过滤

0041

0042	#region 对字符串进行HTML编码，针对(input,Textarea)输入时过滤脚本及HTML编码

0043

/**/

0044	/// <summary>

0045	/// 对字符串进行HTML编码，针对(input,Textarea)输入时过滤脚本及HTML编码

0046	/// </summary>

0047	/// <param name="source"></param>

0048	/// <returns></returns>

0049	#endregion

0050	public static string EncodeToHtml(string source)

0051

{

0052	source = source.Trim();

0053	source = source.Replace("'", "''");

0054	source = source.Replace("\\", "＼");

0055	source = System.Web.HttpContext.Current.Server.HtmlEncode(source);

0056	source = source.Replace("\r\n", "<br>");

0057	source = source.Replace("\n", "<br>");

0058	return source;

0059

}

0060

0061

0062	#region [否决的]对字符串进行HTML编码，针对(input,Textarea)输入时过滤脚本及HTML编码

0063

/**/

0064	/// <summary>

0065	/// [否决的]对字符串进行HTML编码，针对(input,Textarea)输入时过滤脚本及HTML编码 (不符合命名规范，请使用 EncodeToHtml 方法 )

0066	/// </summary>

0067	/// <param name="source"></param>

0068	/// <returns></returns>

0069	#endregion

0070	public static string HtmlFilterForInput(string source)

0071

{

0072	return EncodeToHtml(source);

0073

}

0074

0075

0076	#region 还原HTML编码为字符串,还原HTML编码为字符串，用于返回到input或 Textarea 输入框

0077

/**/

0078	/// <summary>

0079	/// 还原HTML编码为字符串，用于返回到input或 Textarea 输入框

0080	/// </summary>

0081	/// <param name="source"></param>

0082	/// <returns></returns>

0083	#endregion

0084	public static string DecodeFormHtml(string source)

0085

{

0086	source = source.Trim();

0087	source = source.Replace("<br>", "\r\n");

0088	source = source.Replace("<br>", "\n");

0089	source = System.Web.HttpContext.Current.Server.HtmlDecode(source);

0090	return source;

0091

}

0092

0093

0094	#region [否决的]还原HTML编码为字符串,还原HTML编码为字符串，用于返回到input或 Textarea 输入框

0095

/**/

0096	/// <summary>

0097	/// [否决的]还原HTML编码为字符串，用于返回到input或 Textarea 输入框 (不符合命名规范，请使用 DecodeFormHtml 方法 )

0098	/// </summary>

0099	/// <param name="source"></param>

0100	/// <returns></returns>

0101	#endregion

0102	public static string DeHtmlFilterForInput(string source)

0103

{

0104	source = source.Trim();

0105	source = source.Replace("<br>", "\r\n");

0106	source = source.Replace("<br>", "\n");

0107	source = System.Web.HttpContext.Current.Server.HtmlDecode(source);

0108	return source;

0109

}

0110

0111

0112	#region 检验用户提交的URL参数字符里面是否有非法字符

0113

/**/

0114	/// <summary>

0115	/// 检验用户提交的URL参数字符里面是否有非法字符,如果有则返回True.防止SQL注入.

0116	/// </summary>

0117	/// <param name="str">(string)</param>

0118	/// <returns>bool</returns>

0119	public static bool VerifyString(string str)

0120

{

0121	string strTmp = str.ToUpper();

0122	if (strTmp.IndexOf("SELECT ") >= 0 || strTmp.IndexOf(" AND ") >= 0 || strTmp.IndexOf(" OR ") >= 0 ||

0123	strTmp.IndexOf("EXEC ") >= 0 || strTmp.IndexOf("CHAR(") >= 0)

0124

{

0125	return true;

0126

}

0127

0128	strTmp.Replace("'", "＇").Replace(";", "；");

0129	return false;

0130

}

0131

0132	#endregion

0133

0134

0135	#region 过滤 Sql 语句字符串中的注入脚本

0136

/**/

0137	/// <summary>

0138	/// 过滤 Sql 语句字符串中的注入脚本

0139	/// </summary>

0140	/// <param name="source">传入的字符串</param>

0141	/// <returns></returns>

0142	#endregion

0143	public static string FilterSql(string source)

0144

{

0145	//单引号替换成两个单引号

0146	source = source.Replace("'", "''");

0147	source = source.Replace("\"", "“");

0148	source = source.Replace("|", "｜");

0149	//半角封号替换为全角封号，防止多语句执行

0150	source = source.Replace(";", "；");

0151

0152	//半角括号替换为全角括号

0153	source = source.Replace("(", "（");

0154	source = source.Replace(")", "）");

0155

0156

/**/

0157	///////////////要用正则表达式替换，防止字母大小写得情况////////////////////

0158

0159	//去除执行存储过程的命令关键字

0160	source = source.Replace("Exec", "");

0161	source = source.Replace("Execute", "");

0162

0163	//去除系统存储过程或扩展存储过程关键字

0164	source = source.Replace("xp_", "x p_");

0165	source = source.Replace("sp_", "s p_");

0166

0167	//防止16进制注入

0168	source = source.Replace("0x", "0 x");

0169

0170	return source;

0171

}

0172

0173

0174	#region [否决的]过滤 Sql 语句字符串中的注入脚本

0175

/**/

0176	/// <summary>

0177	/// [否决的]过滤 Sql 语句字符串中的注入脚本(请使用 FilterSql 方法 )

0178	/// </summary>

0179	/// <param name="source">传入的字符串</param>

0180	/// <returns></returns>

0181	#endregion

0182	public static string SqlFilter(string source)

0183

{

0184	return FilterSql(source);

0185

}

0186

0187

0188	#region 过滤字符串只剩数字

0189

/**/

0190	/// <summary>

0191	/// 过滤字符串只剩数字

0192	/// </summary>

0193	/// <param name="source">源字符串</param>

0194	#endregion

0195	public static string FilterToNumber(string source)

0196

{

0197	source = Regex.Replace(source, "[^0-9]*", "", System.Text.RegularExpressions.RegexOptions.IgnoreCase);

0198	return source;

0199

}

0200

0201

0202	#region [否决的]过滤字符串只剩数字

0203

/**/

0204	/// <summary>

0205	/// [否决的]过滤字符串只剩数字(请使用 FilterToNumber 方法)

0206	/// </summary>

0207	/// <param name="source">源字符串</param>

0208	#endregion

0209	public static string NumberFilter(string source)

0210

{

0211	source = Regex.Replace(source, "[^0-9]*", "", System.Text.RegularExpressions.RegexOptions.IgnoreCase);

0212	return source;

0213

}

0214

0215

0216	#region 去除数组内重复元素

0217

/**/

0218	/// <summary>

0219	/// 去除数组内重复元素

0220	/// </summary>

0221	/// <param name="arr"></param>

0222	/// <returns></returns>

0223	#endregion

0224	public ArrayList FilterRepeatArrayItem(ArrayList arr)

0225

{

0226

//建立新数组

0227	ArrayList newArr = new ArrayList();

0228

0229	//载入第一个原数组元素

0230	if (arr.Count > 0)

0231

{

0232	newArr.Add(arr[0]);

0233

}

0234

0235

//循环比较

0236	for (int i = 0; i < arr.Count; i++)

0237

{

0238	if (!newArr.Contains(arr[i]))

0239

{

0240	newArr.Add(arr[i]);

0241

}

0242

}

0243	return newArr;

0244

}

0245

0246

0247	#region 在最后去除指定的字符

0248

/**/

0249	/// <summary>

0250	/// 在最后去除指定的字符

0251	/// </summary>

0252	/// <param name="source">参加处理的字符</param>

0253	/// <param name="cutString">要去除的字符</param>

0254	/// <returns>返回结果</returns>

0255	#endregion

0256	public static string CutLastString(string source, string cutString)

0257

{

0258	string result = "";

0259	int tempIndex = 0;

0260

0261	tempIndex = source.LastIndexOf(cutString);

0262	if (cutString.Length == (source.Length - tempIndex))

0263

{

0264	result = source.Substring(0, tempIndex);

0265

}

0266

else

0267

{

0268	result = source;

0269

}

0270

0271	return result;

0272

}

0273

0274

0275	#region 利用正则表达式实现UBB代码转换为html代码

0276

/**/

0277	/// <summary>

0278	/// 利用正则表达式实现UBB代码转换为html代码

0279	/// </summary>

0280	/// <param name="source">待处理的文本内容</param>

0281	/// <returns>返回正确的html代码</returns>

0282	#endregion

0283	public static string UBBCode(string source)

0284

{

0285	if (source == null || source.Length == 0)

0286

{

0287	return "";

0288

}

0289

0290	source = source.Replace(" ", "");

0291	//source=source.Replace("<","&lt");

0292	//source=source.Replace(">","&gt");

0293	source = source.Replace("\n", "<br>");

0294	source = Regex.Replace(source, @"\[url=(?<x>[^\]]*)\](?<y>[^\]]*)\[/url\]", @"<a href=$1 target=_blank>$2</a>", RegexOptions.IgnoreCase);

0295	source = Regex.Replace(source, @"\[url\](?<x>[^\]]*)\[/url\]", @"<a href=$1 target=_blank>$1</a>", RegexOptions.IgnoreCase);

0296	source = Regex.Replace(source, @"\[email=(?<x>[^\]]*)\](?<y>[^\]]*)\[/email\]", @"<a href=$1>$2</a>", RegexOptions.IgnoreCase);

0297	source = Regex.Replace(source, @"\[email\](?<x>[^\]]*)\[/email\]", @"<a href=$1>$1</a>", RegexOptions.IgnoreCase);

0298

source = Regex.Replace(source, @"\[flash](?<x>[^\]]*)\[/flash]", @"<OBJECT codeBase=http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=4,0,2,0 classid=clsid:D27CDB6E-AE6D-11cf-96B8-444553540000 width=500 height=400><PARAM NAME=movie VALUE=""$1""><PARAM NAME=quality VALUE=high><embed src=""$1"" quality=high pluginspage='http://www.macromedia.com/shockwave/download/index.cgi?P1_Prod_Version=ShockwaveFlash' type='application/x-shockwave-flash' width=500 height=400>$1</embed></OBJECT>", RegexOptions.IgnoreCase);

0299	source = Regex.Replace(source, @"\", @"<IMG src=""$1"" border=0>", RegexOptions.IgnoreCase);

0300	source = Regex.Replace(source, @"\[color=(?<x>[^\]]*)\](?<y>[^\]]*)\[/color\]", @"<font color=$1>$2</font>", RegexOptions.IgnoreCase);

0301	source = Regex.Replace(source, @"\[face=(?<x>[^\]]*)\](?<y>[^\]]*)\[/face\]", @"<font face=$1>$2</font>", RegexOptions.IgnoreCase);

0302	source = Regex.Replace(source, @"\[size=1\](?<x>[^\]]*)\[/size\]", @"<font size=1>$1</font>", RegexOptions.IgnoreCase);

0303	source = Regex.Replace(source, @"\[size=2\](?<x>[^\]]*)\[/size\]", @"<font size=2>$1</font>", RegexOptions.IgnoreCase);

0304	source = Regex.Replace(source, @"\[size=3\](?<x>[^\]]*)\[/size\]", @"<font size=3>$1</font>", RegexOptions.IgnoreCase);

0305	source = Regex.Replace(source, @"\[size=4\](?<x>[^\]]*)\[/size\]", @"<font size=4>$1</font>", RegexOptions.IgnoreCase);

0306	source = Regex.Replace(source, @"\[size=5\](?<x>[^\]]*)\[/size\]", @"<font size=5>$1</font>", RegexOptions.IgnoreCase);

0307	source = Regex.Replace(source, @"\[size=6\](?<x>[^\]]*)\[/size\]", @"<font size=6>$1</font>", RegexOptions.IgnoreCase);

0308	source = Regex.Replace(source, @"\[align=(?<x>[^\]]*)\](?<y>[^\]]*)\[/align\]", @"<align=$1>$2</align>", RegexOptions.IgnoreCase);

0309	source = Regex.Replace(source, @"\[fly](?<x>[^\]]*)\[/fly]", @"<marquee width=90% behavior=alternate scrollamount=3>$1</marquee>", RegexOptions.IgnoreCase);

0310	source = Regex.Replace(source, @"\[move](?<x>[^\]]*)\[/move]", @"<marquee scrollamount=3>$1</marquee>", RegexOptions.IgnoreCase);

0311	source = Regex.Replace(source, @"\[glow=(?<x>[^\]]*),(?<y>[^\]]*),(?<z>[^\]]*)\](?<w>[^\]]*)\[/glow\]", @"<table width=$1 style='filter:glow(color=$2, strength=$3)'>$4</table>", RegexOptions.IgnoreCase);

0312	source = Regex.Replace(source, @"\[shadow=(?<x>[^\]]*),(?<y>[^\]]*),(?<z>[^\]]*)\](?<w>[^\]]*)\[/shadow\]", @"<table width=$1 style='filter:shadow(color=$2, strength=$3)'>$4</table>", RegexOptions.IgnoreCase);

0313	source = Regex.Replace(source, @"\[center\](?<x>[^\]]*)\[/center\]", @"<center>$1</center>", RegexOptions.IgnoreCase);

0314	source = Regex.Replace(source, @"\[b\](?<x>[^\]]*)\[/b\]", @"<b>$1</b>", RegexOptions.IgnoreCase);

0315	source = Regex.Replace(source, @"\[i\](?<x>[^\]]*)\[/i\]", @"<i>$1</i>", RegexOptions.IgnoreCase);

0316	source = Regex.Replace(source, @"\[u\](?<x>[^\]]*)\[/u\]", @"<u>$1</u>", RegexOptions.IgnoreCase);

0317	source = Regex.Replace(source, @"\[code\](?<x>[^\]]*)\[/code\]", @"<pre id=code><font size=1 face='Verdana, Arial' id=code>$1</font id=code></pre id=code>", RegexOptions.IgnoreCase);

0318	source = Regex.Replace(source, @"\[list\](?<x>[^\]]*)\[/list\]", @"<ul>$1</ul>", RegexOptions.IgnoreCase);

0319	source = Regex.Replace(source, @"\[list=1\](?<x>[^\]]*)\[/list\]", @"<ol type=1>$1</ol id=1>", RegexOptions.IgnoreCase);

0320	source = Regex.Replace(source, @"\[list=a\](?<x>[^\]]*)\[/list\]", @"<ol type=a>$1</ol id=a>", RegexOptions.IgnoreCase);

0321	source = Regex.Replace(source, @"\[\*\](?<x>[^\]]*)\[/\*\]", @"<li>$1</li>", RegexOptions.IgnoreCase);

0322	source = Regex.Replace(source, @"\[quote](?<x>.*)\[/quote]", @"<center>—— 以下是引用 ——<table border='1' width='80%' cellpadding='10' cellspacing='0' ><tr><td>$1</td></tr></table></center>", RegexOptions.IgnoreCase);

0323

source = Regex.Replace(source, @"\[QT=*([0-9]*),*([0-9]*)\](.[^\[]*)\[\/QT]", @"<embed src=$3 width=$1 height=$2 autoplay=true loop=false controller=true playeveryframe=false cache=false scale=TOFIT bgcolor=#000000 kioskmode=false targetcache=false pluginspage=http://www.apple.com/quicktime/>", RegexOptions.IgnoreCase);

0324

source = Regex.Replace(source, @"\[MP=*([0-9]*),*([0-9]*)\](.[^\[]*)\[\/MP]", @"<object align=center classid=CLSID:22d6f312-b0f6-11d0-94ab-0080c74c7e95 class=OBJECT id=MediaPlayer width=$1 height=$2 ><param name=ShowStatusBar value=-1><param name=Filename value=$3><embed type=application/x-oleobject codebase=http://activex.microsoft.com/activex/controls/mplayer/en/nsmp2inf.cab#Version=5,1,52,701 flename=mp src=$3 width=$1 height=$2></embed></object>", RegexOptions.IgnoreCase);

0325

source = Regex.Replace(source, @"\[RM=*([0-9]*),*([0-9]*)\](.[^\[]*)\[\/RM]", @"<OBJECT classid=clsid:CFCDAA03-8BE4-11cf-B84B-0020AFBBCCFA class=OBJECT id=RAOCX width=$1 height=$2><PARAM NAME=SRC VALUE=$3><PARAM NAME=CONSOLE VALUE=Clip1><PARAM NAME=CONTROLS VALUE=imagewindow><PARAM NAME=AUTOSTART VALUE=true></OBJECT><br><OBJECT classid=CLSID:CFCDAA03-8BE4-11CF-B84B-0020AFBBCCFA height=32 id=video2 width=$1><PARAM NAME=SRC VALUE=$3><PARAM NAME=AUTOSTART VALUE=-1><PARAM NAME=CONTROLS VALUE=controlpanel><PARAM NAME=CONSOLE VALUE=Clip1></OBJECT>", RegexOptions.IgnoreCase);

0326	return (source);

0327

}

0328

0329

0330	#region 整理(过滤)以英文逗号分割的字符串

0331

/**/

0332	/// <summary>

0333	/// 整理(过滤)以英文逗号分割的字符串

0334	/// </summary>

0335	/// <param name="source">原字符串</param>

0336	/// <param name="str2">待清除的字符串，如空格</param>

0337	/// <returns></returns>

0338	#endregion

0339	public static string FilterStringArray(string source, string str2)

0340

{

0341	source = source.Replace(str2, "");

0342	if (source != "")

0343

{

0344	source = source.Replace(",,", ",");

0345

0346	if (source[0].ToString() == ",")

0347

{

0348	source = source.Substring(1, source.Length - 1);

0349

}

0350

0351	if (source[source.Length - 1].ToString() == ",")

0352

{

0353	source = source.Substring(0, source.Length - 1);

0354

}

0355

}

0356	return source;

0357

}

0358

0359

0360	#endregion

0361

0362	#region 字符串组合

0363

0364	#region 返回年月日时分秒组合的字符串

0365

/**/

0366	/// <summary>

0367	/// 返回年月日时分秒组合的字符串,如：20050424143012

0368	/// </summary>

0369	/// <param name="splitString">中间间隔的字符串，如2005\04\24\14\30\12。可以用来建立目录时使用</param>

0370	/// <returns></returns>

0371	#endregion

0372	public static string GetTimeString()

0373

{

0374	//DateTime now = DateTime.Now;

0375

0376	//StringBuilder sb = new StringBuilder();

0377	//sb.Append(now.Year.ToString("0000"));

0378	//sb.Append(splitString);

0379	//sb.Append(now.Month.ToString("00"));

0380	//sb.Append(splitString);

0381	//sb.Append(now.Day.ToString("00"));

0382	//sb.Append(splitString);

0383	//sb.Append(now.Hour.ToString("00"));

0384	//sb.Append(splitString);

0385	//sb.Append(now.Minute.ToString("00"));

0386	//sb.Append(splitString);

0387	//sb.Append(now.Second.ToString("00"));

0388	string kk=Convert.ToString(DateTime.Now.ToString("d")).Trim().Replace("-", "").Replace("/", "2") + Convert.ToString(DateTime.Now.ToString("T")).Trim().Replace(":", "").Replace(" ", "5");

0389

0390	return kk;

0391

}

0392

0393

0394	#region 返回年月日时分秒组合的字符串

0395

/**/

0396	/// <summary>

0397	/// 返回年月日组合的字符串,如：20050424 (2005年4月24日)

0398	/// </summary>

0399	/// <param name="splitString">中间间隔的字符串，如2005\04\24 可以用来建立目录时使用</param>

0400	/// <returns></returns>

0401	#endregion

0402	public static string GetDateString()

0403

{

0404	//DateTime now = DateTime.Now;

0405

0406	//StringBuilder sb = new StringBuilder();

0407	//sb.Append(now.Year.ToString("0000"));

0408	//sb.Append(splitString);

0409	//sb.Append(now.Month.ToString("00"));

0410	//sb.Append(splitString);

0411	//sb.Append(now.Day.ToString("00"));

0412	string kk = Convert.ToString(DateTime.Now.ToString("d")).Trim().Replace("-", "").Replace("/", "2") + Convert.ToString(DateTime.Now.ToString("T")).Trim().Replace(":", "").Replace(" ", "5");

0413	return kk;

0414

}

0415

0416

0417	#endregion

0418

0419	#region 随机字符串,随机数

0420

0421	private static string _LowerChar = "abcdefghijklmnopqrstuvwxyz";

0422	private static string _UpperChar = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

0423	private static string _NumberChar = "0123456789";

0424

0425	#region 获取种子

0426

/**/

0427	/// <summary>

0428	/// 使用RNGCryptoServiceProvider 做种，可以在一秒内产生的随机数重复率非常

0429	/// 的低，对于以往使用时间做种的方法是个升级

0430	/// </summary>

0431	/// <returns></returns>

0432	#endregion

0433	public static int GetNewSeed()

0434

{

0435	byte[] rndBytes = new byte[4];

0436	RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();

0437	rng.GetBytes(rndBytes);

0438	return BitConverter.ToInt32(rndBytes, 0);

0439

}

0440

0441

0442	#region 取得指定范围内的数字随几数

0443

/**/

0444	/// <summary>

0445	/// 取得指定范围内的随几数

0446	/// </summary>

0447	/// <param name="startNumber">下限数</param>

0448	/// <param name="endNumber">上限数</param>

0449	/// <returns>int</returns>

0450	#endregion

0451	public static int GetRandomNumber(int startNumber, int endNumber)

0452

{

0453	Random objRandom = new Random(GetNewSeed());

0454	int r = objRandom.Next(startNumber, endNumber);

0455

return r;

0456

}

0457

0458

0459	#region 获取指定 ASCII 范围内的随机字符串

0460

/**/

0461	/// <summary>

0462	/// 获取指定 ASCII 范围内的随机字符串

0463	/// </summary>

0464	/// <param name="resultLength">结果字符串长度</param>

0465	/// <param name="startNumber"> 开始的ASCII值 如（33－125）中的 33</param>

0466	/// <param name="endNumber"> 结束的ASCII值 如（33－125）中的 125</param>

0467	/// <returns></returns>

0468	#endregion

0469	public static string GetRandomStringByASCII(int resultLength, int startNumber, int endNumber)

0470

{

0471	System.Random objRandom = new System.Random(GetNewSeed());

0472	string result = null;

0473	for (int i = 0; i < resultLength; i++)

0474

{

0475	result += (char)objRandom.Next(startNumber, endNumber);

0476

}

0477	return result;

0478

}

0479

0480

0481	#region 从指定字符串中抽取指定长度的随机字符串

0482

/**/

0483	/// <summary>

0484	/// 从指定字符串中抽取指定长度的随机字符串

0485	/// </summary>

0486	/// <param name="source">源字符串</param>

0487	/// <param name="resultLength">待获取随机字符串长度</param>

0488	/// <returns></returns>

0489	#endregion

0490	private static string GetRandomString(string source, int resultLength)

0491

{

0492	System.Random objRandom = new System.Random(GetNewSeed());

0493	string result = null;

0494	for (int i = 0; i < resultLength; i++)

0495

{

0496	result += source.Substring(objRandom.Next(0, source.Length - 1), 1);

0497

}

0498	return result;

0499

}

0500

0501

0502	#region 获取指定长度随机的数字字符串

0503

/**/

0504	/// <summary>

0505	/// 获取指定长度随机的数字字符串

0506	/// </summary>

0507	/// <param name="resultLength">待获取随机字符串长度</param>

0508	/// <returns></returns>

0509	#endregion

0510	public static string GetRandomNumberString(int resultLength)

0511

{

0512	return GetRandomString(_NumberChar, resultLength);

0513

}

0514

0515

0516	#region 获取指定长度随机的字母字符串（包含大小写字母）

0517

/**/

0518	/// <summary>

0519	/// 获取指定长度随机的字母字符串（包含大小写字母）

0520	/// </summary>

0521	/// <param name="resultLength">待获取随机字符串长度</param>

0522	/// <returns></returns>

0523	#endregion

0524	public static string GetRandomLetterString(int resultLength)

0525

{

0526	return GetRandomString(_LowerChar + _UpperChar, resultLength);

0527

}

0528

0529

0530	#region 获取指定长度随机的字母＋数字混和字符串（包含大小写字母）

0531

/**/

0532	/// <summary>

0533	/// 获取指定长度随机的字母＋数字混和字符串（包含大小写字母）

0534	/// </summary>

0535	/// <param name="resultLength">待获取随机字符串长度</param>

0536	/// <returns></returns>

0537	#endregion

0538	public static string GetRandomMixString(int resultLength)

0539

{

0540	return GetRandomString(_LowerChar + _UpperChar + _NumberChar, resultLength);

0541

}

0542

0543	#endregion

0544

0545	#region 字符串验证

0546

0547	#region 判断字符串是否为整型

0548

/**/

0549	/// <summary>

0550	/// 判断字符串是否为整型

0551	/// </summary>

0552	/// <param name="source"></param>

0553	/// <returns></returns>

0554	#endregion

0555	public static bool IsInteger(string source)

0556

{

0557	if (source == null || source == "")

0558

{

0559	return false;

0560

}

0561

0562	if (Regex.IsMatch(source, "^((\\+)\\d)?\\d*$"))

0563

{

0564	return true;

0565

}

0566

else

0567

{

0568	return false;

0569

}

0570

}

0571

0572

0573	#region Email 格式是否合法

0574

/**/

0575	/// <summary>

0576	/// Email 格式是否合法

0577	/// </summary>

0578	/// <param name="strEmail"></param>

0579	#endregion

0580	public static bool IsEmail(string strEmail)

0581

{

0582	return Regex.IsMatch(strEmail, @"^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$");

0583

}

0584

0585

0586	#region 判断是否IP

0587

/**/

0588	/// <summary>

0589	/// 判断是否IP

0590	/// </summary>

0591	/// <param name="source"></param>

0592	/// <returns></returns>

0593	#endregion

0594	public static bool IsIP(string source)

0595

{

0596

return Regex.IsMatch(source, @"^(((25[0-5]|2[0-4][0-9]|19[0-1]|19[3-9]|18[0-9]|17[0-1]|17[3-9]|1[0-6][0-9]|1[1-9]|[2-9][0-9]|[0-9])\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9]))|(192\.(25[0-5]|2[0-4][0-9]|16[0-7]|169|1[0-5][0-9]|1[7-9][0-9]|[1-9][0-9]|[0-9]))|(172\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|1[0-5]|3[2-9]|[4-9][0-9]|[0-9])))\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$");

0597

}

0598

0599

0600	#region 检查字符串是否为A-Z、0-9及下划线以内的字符

0601

0602

/**/

0603	/// <summary>

0604	/// 检查字符串是否为A-Z、0-9及下划线以内的字符

0605	/// </summary>

0606	/// <param name="str">被检查的字符串</param>

0607	/// <returns>是否有特殊字符</returns>

0608	#endregion

0609	public static bool IsLetterOrNumber(string str)

0610

{

0611	bool b = System.Text.RegularExpressions.Regex.IsMatch(str, "[a-zA-Z0-9_]");

0612

return b;

0613

}

0614

0615

0616	#region 验输入字符串是否含有“/\<>:.?*|$]”特殊字符

0617

/**/

0618	/// <summary>

0619	/// 验输入字符串是否含有“/\:.?*|$]”特殊字符

0620	/// </summary>

0621	/// <param name="source"></param>

0622	/// <returns></returns>

0623	#endregion

0624	public static bool IsSpecialChar(string source)

0625

{

0626	Regex r = new Regex(@"[/\<>:.?*|$]");

0627	return r.IsMatch(source);

0628

}

0629

0630

0631	#region 是否全为中文/日文/韩文字符

0632

/**/

0633	/// <summary>

0634	/// 是否全为中文/日文/韩文字符

0635	/// </summary>

0636	/// <param name="source">源字符串</param>

0637	/// <returns></returns>

0638	#endregion

0639	public static bool IsChineseChar(string source)

0640

{

0641	//中文/日文/韩文: [\u4E00-\u9FA5]

0642	//英文:[a-zA-Z]

0643	return Regex.IsMatch(source, @"^[\u4E00-\u9FA5]+$");

0644

}

0645

0646

0647	#region 是否包含双字节字符(允许有单字节字符)

0648

/**/

0649	/// <summary>

0650	/// 是否包含双字节字符(允许有单字节字符)

0651	/// </summary>

0652	/// <param name="source"></param>

0653	/// <returns></returns>

0654	#endregion

0655	public static bool IsDoubleChar(string source)

0656

{

0657	return Regex.IsMatch(source, @"[^\x00-\xff]");

0658

}

0659

0660

0661	#region 是否为日期型字符串

0662

/**/

0663	/// <summary>

0664	/// 是否为日期型字符串

0665	/// </summary>

0666	/// <param name="source">日期字符串(2005-6-30)</param>

0667	/// <returns></returns>

0668	#endregion

0669	public static bool IsDate(string source)

0670

{

0671

return Regex.IsMatch(source, @"^((((1[6-9]|[2-9]\d)\d{2})-(0?[13578]|1[02])-(0?[1-9]|[12]\d|3[01]))|(((1[6-9]|[2-9]\d)\d{2})-(0?[13456789]|1[012])-(0?[1-9]|[12]\d|30))|(((1[6-9]|[2-9]\d)\d{2})-0?2-(0?[1-9]|1\d|2[0-8]))|(((1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))-0?2-29-))$");

0672

}

0673

0674

0675	#region 是否为时间型字符串

0676

/**/

0677	/// <summary>

0678	/// 是否为时间型字符串

0679	/// </summary>

0680	/// <param name="source">时间字符串(15:00:00)</param>

0681	/// <returns></returns>

0682	#endregion

0683	public static bool IsTime(string source)

0684

{

0685	return Regex.IsMatch(source, @"^((20|21|22|23|[0-1]?\d):[0-5]?\d:[0-5]?\d)$");

0686

}

0687

0688

0689	#region 是否为日期+时间型字符串

0690

/**/

0691	/// <summary>

0692	/// 是否为日期+时间型字符串

0693	/// </summary>

0694	/// <param name="source"></param>

0695	/// <returns></returns>

0696	#endregion

0697	public static bool IsDateTime(string source)

0698

{

0699

return Regex.IsMatch(source, @"^((((1[6-9]|[2-9]\d)\d{2})-(0?[13578]|1[02])-(0?[1-9]|[12]\d|3[01]))|(((1[6-9]|[2-9]\d)\d{2})-(0?[13456789]|1[012])-(0?[1-9]|[12]\d|30))|(((1[6-9]|[2-9]\d)\d{2})-0?2-(0?[1-9]|1\d|2[0-8]))|(((1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))-0?2-29-)) ((20|21|22|23|[0-1]?\d):[0-5]?\d:[0-5]?\d)$");

0700

}

0701

0702

0703	#region 是否为钱币型数据

0704

/**/

0705	/// <summary>

0706	/// 是否为钱币型数据

0707	/// </summary>

0708	/// <param name="source"></param>

0709	/// <returns></returns>

0710	#endregion

0711	public static bool IsMoney(string source)

0712

{

0713	return false;

0714

}

0715

0716	#endregion

0717

0718	#region 字符串截取

0719

0720	#region 获取字符串的实际长度(按单字节)

0721

/**/

0722	/// <summary>

0723	/// 获取字符串的实际长度(按单字节)

0724	/// </summary>

0725	/// <param name="source"></param>

0726	/// <returns></returns>

0727	#endregion

0728	public static int GetRealLength(string source)

0729

{

0730	return System.Text.Encoding.Default.GetByteCount(source);

0731

}

0732

0733

0734	#region 取得固定长度的字符串(按单字节截取)

0735

/**/

0736	/// <summary>

0737	/// 取得固定长度的字符串(按单字节截取)。

0738	/// </summary>

0739	/// <param name="source">源字符串</param>

0740	/// <param name="resultLength">截取长度</param>

0741	/// <returns></returns>

0742	#endregion

0743	public static string SubString(string source, int resultLength)

0744

{

0745

0746	//判断字符串长度是否大于截断长度

0747	if (System.Text.Encoding.Default.GetByteCount(source) > resultLength)

0748

{

0749	//判断字串是否为空

0750	if (source == null)

0751

{

0752	return "";

0753

}

0754

0755

//初始化

0756	int i = 0, j = 0;

0757

0758	//为汉字或全脚符号长度加2否则加1

0759	foreach (char newChar in source)

0760

{

0761	if ((int)newChar > 127)

0762

{

0763

i += 2;

0764

}

0765

else

0766

{

0767

i++;

0768

}

0769	if (i > resultLength)

0770

{

0771	source = source.Substring(0, j);

0772

break;

0773

}

0774

j++;

0775

}

0776

}

0777	return source;

0778

}

0779

0780

0781	#region 按长度分割字符串

0782

/**/

0783	/// <summary>

0784	/// 按长度分割字符串，如短信

0785	/// </summary>

0786	/// <param name="str"></param>

0787	/// <param name="len"></param>

0788	/// <returns></returns>

0789	#endregion

0790	private ArrayList SplitStringByLength(string str, int len)

0791

{

0792	ArrayList arrBlock = new ArrayList();

0793	int intBlockCount = str.Length / len;

0794	if (str.Length % len != 0)

0795

{

0796	for (int i = 0; i <= intBlockCount; i++)

0797

{

0798	if ((str.Length - i * len) > len)

0799	arrBlock.Add(str.Substring(i * len, len));

0800

else

0801	arrBlock.Add(str.Substring(i * len, (str.Length % len)));

0802

}

0803

}

0804

else

0805

{

0806	for (int i = 0; i < intBlockCount; i++)

0807

{

0808	arrBlock.Add(str.Substring(i * len, len));

0809

}

0810

}

0811	return arrBlock;

0812

}

0813

0814

0815	#endregion

0816

0817	#region 字符串比较

0818

0819

/**/

0820	/// <summary>

0821	///  获得某个字符串在另个字符串中出现的次数

0822	/// </summary>

0823	/// <param name="strOriginal">要处理的字符</param>

0824	/// <param name="strSymbol">符号</param>

0825	/// <returns>返回值</returns>

0826	public static int GetStringIncludeCount(string strOriginal, string strSymbol)

0827

{

0828

0829	int count = 0;

0830	count = strOriginal.Length - strOriginal.Replace(strSymbol, String.Empty).Length;

0831	return count;

0832

}

0833

0834

/**/

0835	/// <summary>

0836	/// 获得某个字符串在另个字符串第一次出现时前面所有字符

0837	/// </summary>

0838	/// <param name="strOriginal">要处理的字符</param>

0839	/// <param name="strSymbol">符号</param>

0840	/// <returns>返回值</returns>

0841	public static string GetFirstString(string strOriginal, string strSymbol)

0842

{

0843	int strPlace = strOriginal.IndexOf(strSymbol);

0844	if (strPlace != -1)

0845

{

0846	strOriginal = strOriginal.Substring(0, strPlace);

0847

}

0848	return strOriginal;

0849

}

0850

0851

/**/

0852	/// <summary>

0853	/// 获得某个字符串在另个字符串最后一次出现时后面所有字符

0854	/// </summary>

0855	/// <param name="strOriginal">要处理的字符</param>

0856	/// <param name="strSymbol">符号</param>

0857	/// <returns>返回值</returns>

0858	public static string GetLastString(string strOriginal, string strSymbol)

0859

{

0860	int strPlace = strOriginal.LastIndexOf(strSymbol) + strSymbol.Length;

0861	strOriginal = strOriginal.Substring(strPlace);

0862	return strOriginal;

0863

}

0864

0865

/**/

0866	/// <summary>

0867	/// 获得两个字符之间第一次出现时前面所有字符

0868	/// </summary>

0869	/// <param name="strOriginal">要处理的字符</param>

0870	/// <param name="strFirst">最前哪个字符</param>

0871	/// <param name="strLast">最后哪个字符</param>

0872	/// <returns>返回值</returns>

0873	public static string GetTwoMiddleFirstStr(string strOriginal, string strFirst, string strLast)

0874

{

0875	strOriginal = GetFirstString(strOriginal, strLast);

0876	strOriginal = GetLastString(strOriginal, strFirst);

0877	return strOriginal;

0878

}

0879

0880

/**/

0881	/// <summary>

0882	///  获得两个字符之间最后一次出现时的所有字符

0883	/// </summary>

0884	/// <param name="strOriginal">要处理的字符</param>

0885	/// <param name="strFirst">最前哪个字符</param>

0886	/// <param name="strLast">最后哪个字符</param>

0887	/// <returns>返回值</returns>

0888	public static string GetTwoMiddleLastStr(string strOriginal, string strFirst, string strLast)

0889

{

0890	strOriginal = GetLastString(strOriginal, strFirst);

0891	strOriginal = GetFirstString(strOriginal, strLast);

0892	return strOriginal;

0893

}

0894

0895

/**/

0896	/// <summary>

0897	/// 发帖过滤词（用“|”号分隔）Application["app_state_FilterWord"]

0898	/// </summary>

0899	/// <param name="str">字符串</param>

0900	/// <param name="chkword">过滤词（用“|”号分隔）</param>

0901	public static bool CheckBadWords(string str, string chkword)

0902

{

0903	if (chkword != null && chkword != "")

0904

{

0905	string filter = chkword;

0906	string chk1 = "";

0907	string[] aryfilter = filter.Split('|');

0908	for (int i = 0; i < aryfilter.Length; i++)

0909

{

0910	chk1 = aryfilter[i].ToString();

0911	if (str.IndexOf(chk1) >= 0)

0912	return true;

0913

}

0914

}

0915	return false;

0916

}

0917

0918

/**/

0919	/// <summary>

0920	/// 发帖过滤字(需审核)（不同组间用“§”号分隔，同组内用“,”分隔）Application["app_state_Check_FilterWord"]

0921	/// </summary>

0922	/// <param name="str">字符串</param>

0923	/// <param name="chkword">过滤字(需审核)（不同组间用“§”号分隔，同组内用“,”分隔）</param>

0924	public static bool CheckilterStr(string str, string chkword)

0925

{

0926

0927	if (chkword != null && chkword != "")

0928

{

0929	string filter = chkword;

0930	string[] aryfilter = filter.Split('§');

0931	string[] aryfilter_lei;

0932	int lei_for = 0, j;

0933

0934	for (int i = 0; i < aryfilter.Length; i++)

0935

{

0936	lei_for = 0;

0937	aryfilter_lei = aryfilter[i].Split(',');

0938	for (j = 0; j < aryfilter_lei.Length; j++)

0939

{

0940	if (str.IndexOf(aryfilter_lei[j].ToString()) >= 0)

0941	lei_for += 1;

0942

}

0943	if (lei_for == aryfilter_lei.Length)

0944	return true;

0945

}

0946

}

0947	return false;

0948

}

0949

0950

0951	#endregion

0952

0953	#region 字符集转换

0954

0955	#region 将 GB2312 值转换为 UTF8 字符串(如：测试 -> 娴嬭瘯 )

0956

/**/

0957	/// <summary>

0958	/// 将 GB2312 值转换为 UTF8 字符串(如：测试 -> 娴嬭瘯 )

0959	/// </summary>

0960	/// <param name="source"></param>

0961	/// <returns></returns>

0962	#endregion

0963	public static string ConvertGBToUTF8(string source)

0964

{

0965

/**/

0966

/*

0967	byte[] bytes;

0968	bytes = System.Text.Encoding.Default.GetBytes(source);

0969	System.Text.Decoder gbDecoder = System.Text.Encoding.GetEncoding("gb2312").GetDecoder();

0970	int charCount = gbDecoder.GetCharCount(bytes,0 , bytes.Length);

0971	Char[] chars = new Char[charCount];

0972	int charsDecodedCount = gbDecoder.GetChars(bytes,0,bytes.Length,chars,0);

0973	return new string(chars);

0974

*/

0975

0976	return Encoding.GetEncoding("GB2312").GetString(Encoding.UTF8.GetBytes(source));

0977

}

0978

0979

0980	#region 将 UTF8 值转换为 GB2312 字符串 (如：娴嬭瘯 -> 测试)

0981

/**/

0982	/// <summary>

0983	/// 将 UTF8 值转换为 GB2312 字符串 (如：娴嬭瘯 -> 测试)

0984	/// </summary>

0985	/// <param name="source"></param>

0986	/// <returns></returns>

0987	#endregion

0988	public static string ConvertUTF8ToGB(string source)

0989

{

0990

/**/

0991

/*

0992	byte[] bytes;

0993

//模拟编码

0994	System.Text.UTF8Encoding utf8 = new System.Text.UTF8Encoding();

0995	bytes = utf8.GetBytes(source);

0996

0997

//开始解码

0998	System.Text.Decoder utf8Decoder = System.Text.Encoding.UTF8.GetDecoder();

0999

1000	int charCount = utf8Decoder.GetCharCount(bytes, 0, bytes.Length);

1001	Char[] chars = new Char[charCount];

1002	int charsDecodedCount = utf8Decoder.GetChars(bytes, 0, bytes.Length, chars, 0);

1003

1004	return new string(chars);

1005

*/

1006

1007	return Encoding.UTF8.GetString(Encoding.GetEncoding("GB2312").GetBytes(source));

1008

}

1009

1010

1011	#region 由16进制转为汉字字符串（如：B2E2 -> 测 ）

1012

/**/

1013	/// <summary>

1014	/// 由16进制转为汉字字符串（如：B2E2 -> 测 ）

1015	/// </summary>

1016	/// <param name="source"></param>

1017	/// <returns></returns>

1018	#endregion

1019	public static string ConvertHexToString(string source)

1020

{

1021	byte[] oribyte = new byte[source.Length / 2];

1022	for (int i = 0; i < source.Length; i += 2)

1023

{

1024	string str = Convert.ToInt32(source.Substring(i, 2), 16).ToString();

1025	oribyte[i / 2] = Convert.ToByte(source.Substring(i, 2), 16);

1026

}

1027	return System.Text.Encoding.Default.GetString(oribyte);

1028

}

1029

1030

1031	#region  字符串转为16进制字符串（如：测 -> B2E2 ）

1032

/**/

1033	/// <summary>

1034	/// 字符串转为16进制字符串（如：测 -> B2E2 ）

1035	/// </summary>

1036	/// <param name="Word"></param>

1037	/// <returns></returns>

1038	#endregion

1039	public static string ConvertToHex(string Word)

1040

{

1041	int i = Word.Length;

1042	string temp;

1043	string end = "";

1044	byte[] array = new byte[2];

1045	int i1, i2;

1046	for (int j = 0; j < i; j++)

1047

{

1048	temp = Word.Substring(j, 1);

1049	array = System.Text.Encoding.Default.GetBytes(temp);

1050	if (array.Length.ToString() == "1")

1051

{

1052	i1 = Convert.ToInt32(array[0]);

1053	end += Convert.ToString(i1, 16);

1054

}

1055

else

1056

{

1057	i1 = Convert.ToInt32(array[0]);

1058	i2 = Convert.ToInt32(array[1]);

1059	end += Convert.ToString(i1, 16);

1060	end += Convert.ToString(i2, 16);

1061

}

1062

}

1063	return end.ToUpper();

1064

}

1065

1066

1067	#region 字符串转为unicode字符串（如：测试 -> 测试）

1068

/**/

1069	/// <summary>

1070	/// 字符串转为unicode字符串（如：测试 -> 测试）

1071	/// </summary>

1072	/// <param name="source"></param>

1073	/// <returns></returns>

1074	#endregion

1075	public static string ConvertToUnicode(string source)

1076

{

1077	StringBuilder sa = new StringBuilder();//Unicode

1078	string s1;

1079	string s2;

1080	for (int i = 0; i < source.Length; i++)

1081

{

1082	byte[] bt = System.Text.Encoding.Unicode.GetBytes(source.Substring(i, 1));

1083	if (bt.Length > 1)//判断是否汉字

1084

{

1085	s1 = Convert.ToString((short)(bt[1] - '\0'), 16);//转化为16进制字符串

1086	s2 = Convert.ToString((short)(bt[0] - '\0'), 16);//转化为16进制字符串

1087	s1 = (s1.Length == 1 ? "0" : "") + s1;//不足位补0

1088	s2 = (s2.Length == 1 ? "0" : "") + s2;//不足位补0

1089	sa.Append("&#" + Convert.ToInt32(s1 + s2, 16) + ";");

1090

}

1091

}

1092

1093	return sa.ToString();

1094

}

1095

1096

1097	#region 字符串转为UTF8字符串（如：测试 -> \u6d4b\u8bd5）

1098

/**/

1099	/// <summary>

1100	/// 字符串转为UTF8字符串（如：测试 -> \u6d4b\u8bd5）

1101	/// </summary>

1102	/// <param name="source"></param>

1103	/// <returns></returns>

1104	#endregion

1105	public static string ConvertToUTF8(string source)

1106

{

1107	StringBuilder sb = new StringBuilder();//UTF8

1108	string s1;

1109	string s2;

1110	for (int i = 0; i < source.Length; i++)

1111

{

1112	byte[] bt = System.Text.Encoding.Unicode.GetBytes(source.Substring(i, 1));

1113	if (bt.Length > 1)//判断是否汉字

1114

{

1115	s1 = Convert.ToString((short)(bt[1] - '\0'), 16);//转化为16进制字符串

1116	s2 = Convert.ToString((short)(bt[0] - '\0'), 16);//转化为16进制字符串

1117	s1 = (s1.Length == 1 ? "0" : "") + s1;//不足位补0

1118	s2 = (s2.Length == 1 ? "0" : "") + s2;//不足位补0

1119	sb.Append("\\u" + s1 + s2);

1120

}

1121

}

1122

1123	return sb.ToString();

1124

}

1125

1126

1127	#region 转化为ASC码方法

1128	//转化为ASC码方法

1129

1130	public string ConvertToAsc(string txt)

1131

{

1132	string newtxt = "";

1133	foreach (char c in txt)

1134

{

1135

1136	newtxt += Convert.ToString((int)c);

1137

}

1138	return newtxt;

1139

1140

}

1141	#endregion

1142

1143	#region BASE64

1144

1145

/**/

1146	/// <summary>

1147	/// 将字符串使用base64算法加密

1148	/// </summary>

1149	/// <param name="source">待加密的字符串</param>

1150	/// <returns>加码后的文本字符串</returns>

1151	public static string Base64_Encrypt(string source)

1152

{

1153	return Convert.ToBase64String(System.Text.Encoding.Default.GetBytes(source));

1154

}

1155

1156

/**/

1157	/// <summary>

1158	/// 从Base64编码的字符串中还原字符串，支持中文

1159	/// </summary>

1160	/// <param name="source">Base64加密后的字符串</param>

1161	/// <returns>还原后的文本字符串</returns>

1162	public static string Base64_Decrypt(string source)

1163

{

1164	return System.Text.Encoding.Default.GetString(Convert.FromBase64String(source));

1165

}

1166	#endregion

1167

1168	#endregion

1169

1170	#region 字符串格式化

1171

1172	#region 将字符串反转

1173

/**/

1174	/// <summary>

1175	/// 将字符串反转

1176	/// </summary>

1177	/// <param name="source"></param>

1178	/// <returns></returns>

1179	#endregion

1180	public static string FormatReverse(string source)

1181

{

1182	char[] ca = source.ToCharArray();

1183	Array.Reverse(ca);

1184	source = new String(ca);

1185	return source;

1186

}

1187

1188

1189

/**/

1190	/// <summary>

1191	/// 格式化为小数点两位的字符串(四舍五入)

1192	/// </summary>

1193	/// <param name="source"></param>

1194	/// <returns></returns>

1195	public static string FormatFloat2(double source)

1196

{

1197	//double tmp=1223333.24215265652;

1198	return source.ToString("##,###.000");

1199

}

1200

1201

1202

/**/

1203	/// <summary>

1204	/// 将数字字符串转成货币格式

1205	/// </summary>

1206	/// <returns></returns>

1207	public static string GetMoneyFormat()

1208

{

1209

/**/

1210

/*

1211	string.Format("${0:###,###,###.##}元",decimalVar);

1212	--------------------------------------------------------------------------------

1213	找到system.string的format方法

1214	string str="99988"

1215	str=format(str,"##,####.00")

1216	str value is:99,988.00

1217

试一下行不行

1218	--------------------------------------------------------------------------------

1219	string strMoney="544.54";

1220	decimal decMoney=System.Convert.ToDecimal(strMoney);

1221	string money=decMoney.ToString("c");

1222

1223	如果要转换成不同地区的符号，可以用：

1224	CultureInfo MyCulture =  new CultureInfo("zh-CN");

1225	String MyString = MyInt.ToString("C", MyCulture);

1226

1227	注意:这里OrderTotal的格式只能是Decimal.

1228

1229

*/

1230	return "";

1231

}

1232

1233

1234

/**/

1235	/// <summary>

1236	/// 格式化字符串 字符串1234567,想变成1,234,567

1237	/// </summary>

1238	/// <param name="source"></param>

1239	/// <returns></returns>

1240	public static string GetO1(string source)

1241

{

1242	//return source.ToString("N");

1243	//return    source.ToString("###,###");

1244	return "";

1245

}

1246

1247

1248

/**/

1249	/// <summary>

1250	/// 十进制数字1转换为字符串0a，在前面补零

1251	/// </summary>

1252	/// <param name="source"></param>

1253	/// <returns></returns>

1254	public static string OctToHex(int source)

1255

{

1256	return source.ToString("X2");

1257

}

1258

1259

1260

/**/

1261	/// <summary>

1262	/// 将一个十六进制表示的字符串转成int型？如"0A" = 10

1263	/// </summary>

1264	/// <param name="source"></param>

1265	/// <returns></returns>

1266	public static string HexToOct(string source)

1267

{

1268	return Convert.ToInt16(source, 16).ToString();

1269

}

1270

1271

1272	#endregion

1273

1274	#region 身份证验证

1275

1276	#region 从18位身份证获取用户所在省份、生日、性别信息

1277

/**/

1278	/// <summary>

1279	/// 从18位身份证获取用户所在省份、生日、性别信息

1280	/// </summary>

1281	/// <param name="cid">身份证字符串</param>

1282	/// <returns>如：福建,1978-06-30,男</returns>

1283	#endregion

1284	public static string GetCidInfo(string cid)

1285

{

1286

string[] aCity = new string[] { null, null, null, null, null, null, null, null, null, null, null, "北京", "天津", "河北", "山西", "内蒙古", null, null, null, null, null, "辽宁", "吉林", "黑龙江", null, null, null, null, null, null, null, "上海", "江苏", "浙江", "安微", "福建", "江西", "山东", null, null, null, "河南", "湖北", "湖南", "广东", "广西", "海南", null, null, null, "重庆", "四川", "贵州", "云南", "西藏", null, null, null, null, null, null, "陕西", "甘肃", "青海", "宁夏", "***", null, null, null, null, null, "台湾", null, null, null, null, null, null, null, null, null, "香港", "澳门", null, null, null, null, null, null, null, null, "国外" };

1287	double iSum = 0;

1288	System.Text.RegularExpressions.Regex rg = new System.Text.RegularExpressions.Regex(@"^\d{17}(\d|x)$");

1289	System.Text.RegularExpressions.Match mc = rg.Match(cid);

1290	if (!mc.Success)

1291

{

1292	return "";

1293

}

1294	cid = cid.ToLower();

1295	cid = cid.Replace("x", "a");

1296	if (aCity[int.Parse(cid.Substring(0, 2))] == null)

1297

{

1298	return "非法地区";

1299

}

1300

try

1301

{

1302	DateTime.Parse(cid.Substring(6, 4) + "-" + cid.Substring(10, 2) + "-" + cid.Substring(12, 2));

1303

}

1304

catch

1305

{

1306	return "非法生日";

1307

}

1308	for (int i = 17; i >= 0; i--)

1309

{

1310	iSum += (System.Math.Pow(2, i) % 11) * int.Parse(cid[17 - i].ToString(), System.Globalization.NumberStyles.HexNumber);

1311

1312

}

1313	if (iSum % 11 != 1)

1314	return ("非法证号");

1315

1316	return (aCity[int.Parse(cid.Substring(0, 2))] + "," + cid.Substring(6, 4) + "-" + cid.Substring(10, 2) + "-" + cid.Substring(12, 2) + "," + (int.Parse(cid.Substring(16, 1)) % 2 == 1 ? "男" : "女"));

1317

1318

}

1319

1320

1321	#region 十五位的身份证号转为十八位的

1322

/**/

1323	/// <summary>

1324	/// 十五位的身份证号转为十八位的

1325	/// </summary>

1326	/// <param name="source">十五位的身份证号</param>

1327	/// <returns></returns>

1328	#endregion

1329	public static string Cid15To18(string source)

1330

{

1331	string[] arrInt = new string[17] { "7", "9", "10", "5", "8", "4", "2", "1", "6", "3", "7", "9", "10", "5", "8", "4", "2" };

1332	string[] arrCh = new string[11] { "1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2" };

1333

1334	int nTemp = 0, i;

1335

1336	if (source.Length == 15)

1337

{

1338	source = source.Substring(0, 6) + "19" + source.Substring(6, source.Length - 6);

1339	for (i = 0; i < source.Length; i++)

1340

{

1341	nTemp += int.Parse(source.Substring(i, 1)) * int.Parse(arrInt[i]);

1342

}

1343	source += arrCh[nTemp % 11];

1344

1345	return source;

1346

}

1347

else

1348

{

1349	return null;

1350

}

1351

1352

}

1353	#endregion

1354

1355	#region 随机数

1356	public static string GetRandNum(int randNumLength)

1357

{

1358	System.Random randNum = new System.Random(unchecked((int)DateTime.Now.Ticks));

1359	StringBuilder sb = new StringBuilder(randNumLength);

1360	for (int i = 0; i < randNumLength; i++)

1361

{

1362	sb.Append(randNum.Next(0, 9));

1363

}

1364	return sb.ToString();

1365

}

1366

1367	#endregion

1368

1369	#region 过滤HTML代码的函数

1370	/// <summary>

1371	/// 过滤HTML代码的函数

1372	/// </summary>

1373	/// <param name="html"></param>

1374	/// <returns></returns>

1375	public string HtmlStr(string html)

1376

{

1377	System.Text.RegularExpressions.Regex regex1 = new System.Text.RegularExpressions.Regex(@"<script[\s\S]+</script *>", System.Text.RegularExpressions.RegexOptions.IgnoreCase);

1378	System.Text.RegularExpressions.Regex regex2 = new System.Text.RegularExpressions.Regex(@" href *= *[\s\S]*script *:", System.Text.RegularExpressions.RegexOptions.IgnoreCase);

1379	System.Text.RegularExpressions.Regex regex3 = new System.Text.RegularExpressions.Regex(@" no[\s\S]*=", System.Text.RegularExpressions.RegexOptions.IgnoreCase);

1380	System.Text.RegularExpressions.Regex regex4 = new System.Text.RegularExpressions.Regex(@"<iframe[\s\S]+</iframe *>", System.Text.RegularExpressions.RegexOptions.IgnoreCase);

1381	System.Text.RegularExpressions.Regex regex5 = new System.Text.RegularExpressions.Regex(@"<frameset[\s\S]+</frameset *>", System.Text.RegularExpressions.RegexOptions.IgnoreCase);

1382	System.Text.RegularExpressions.Regex regex6 = new System.Text.RegularExpressions.Regex(@"\<img[^\>]+\>", System.Text.RegularExpressions.RegexOptions.IgnoreCase);

1383	System.Text.RegularExpressions.Regex regex7 = new System.Text.RegularExpressions.Regex(@"</p>", System.Text.RegularExpressions.RegexOptions.IgnoreCase);

1384	System.Text.RegularExpressions.Regex regex8 = new System.Text.RegularExpressions.Regex(@"<p>", System.Text.RegularExpressions.RegexOptions.IgnoreCase);

1385	System.Text.RegularExpressions.Regex regex9 = new System.Text.RegularExpressions.Regex(@"<[^>]*>", System.Text.RegularExpressions.RegexOptions.IgnoreCase);

1386	html = regex1.Replace(html, ""); //过滤<script></script>标记

1387	html = regex2.Replace(html, ""); //过滤href=javascript: (<A>) 属性

1388

1389

1390	html = regex3.Replace(html, " _disibledevent="); //过滤其它控件的on...事件

1391	html = regex4.Replace(html, ""); //过滤iframe

1392	html = regex5.Replace(html, ""); //过滤frameset

1393	html = regex6.Replace(html, ""); //过滤frameset

1394	html = regex7.Replace(html, ""); //过滤frameset

1395	html = regex8.Replace(html, ""); //过滤frameset

1396	html = regex9.Replace(html, "");

1397	html = html.Replace(" ", "");

1398

1399

1400	html = html.Replace("</strong>", "");

1401	html = html.Replace("<strong>", "");

1402	return html;

1403

}

1404	#endregion

1405

1406

1407

}

1408

}