202309U/YZXYH2017/CommonTool/UtilStr.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Printing;
using System.Globalization;
using System.Text;

namespace CommonTool
{
	public sealed class UtilStr
	{
		/// <summary>
		/// 得到该对象的字符串，在字符串的两边加上“[”“]”
		/// </summary>
		/// <param name="poObject">处理的对象</param>
		/// <returns>字符串</returns>
		public static string GetDelimitedStr(object poObject)
		{
			return ("[" + poObject + "]");
		}

		/// <summary>
		/// 连接连个对象的字符串型，并把他们连接成一个字符串返回出来。
		/// </summary>
		/// <param name="poFirst"></param>
		/// <param name="poSecond"></param>
		/// <returns></returns>
		public static string JoinString(object poFirst, object poSecond)
		{
			return string.Format("[{0}],[{1}]", poFirst.ToString().Trim(), poSecond.ToString().Trim());
		}

		/// <summary>
		/// 将一个对象以字符串形式与另外一个字符串进行连接,并添加“[”，“]”标识符号
		/// </summary>
		/// <param name="pcSource">被连接的字符串</param>
		/// <param name="poTobeAppended">连接的字符串</param>
		/// <returns>返回值</returns>
		public static string AddStr(string pcSource, object poTobeAppended)
		{
			string lcStr = GetDelimitedStr(poTobeAppended);
			pcSource = pcSource.Trim();
			if (pcSource == "")
			{
				return lcStr;
			}
			if ((pcSource[0] == '[') && (pcSource[pcSource.Length - 1] == ']'))
			{
				return (pcSource + string.Format(",[{0}]", poTobeAppended.ToString().Trim()));
			}
			return JoinString(pcSource, poTobeAppended);
		}


		/// <summary>
		/// 直接连接两个字符串
		/// </summary>
		/// <param name="pcSource"></param>
		/// <param name="poTobeAppended"></param>
		/// <returns></returns>
		public static string AppendToStr(string pcSource, object poTobeAppended)
		{
			string lcStr = GetDelimitedStr(poTobeAppended);
			pcSource = pcSource.Trim();
			if (pcSource != "")
			{
				lcStr = pcSource + "," + lcStr;
			}
			return lcStr;
		}

		/// <summary>
		/// 将一个Array转换成字符串，默认分割符为","
		/// </summary>
		/// <param name="paStr"></param>
		/// <returns></returns>
		public static string ArrayToStr(Array paStr)
		{
			return ArrayToStrEx(paStr, ",");
		}

		/// <summary>
		/// 根据传入的分割符号将Array 转换成字符串
		/// </summary>
		/// <param name="paStr"></param>
		/// <param name="pcSeparator"></param>
		/// <returns></returns>
		public static string ArrayToStrEx(Array paStr, string pcSeparator)
		{
			string lcStr = "";
			foreach (string lcStr2 in paStr)
			{
				lcStr = lcStr + ((lcStr == "") ? "" : pcSeparator) + GetDelimitedStr(lcStr2);
			}
			return lcStr;
		}

		/// <summary>
		/// 将字符串转换成Array 对象 ,以","为分割符。
		/// </summary>
		/// <param name="str"></param>
		/// <returns></returns>
		public static Array StrToArray(string str)
		{
			return StrToArrayEx(str, ",");
		}

		/// <summary>
		///  将一个字符串以分割符转换成Array对象，如 a,[b,[c,d]],e 将分割成 a ; b,[c,d] ; e 三个串
		/// </summary>
		/// <param name="str"></param>
		/// <param name="separator"></param>
		/// <returns></returns>
		public static Array StrToArrayEx(string str, string separator)
		{
			ArrayList list1 = new ArrayList();
			str = str?.Trim() ?? "";
			int num1 = separator.Length;
			while (str.Length > 0)
			{
				int num2 = str.IndexOf(separator, StringComparison.Ordinal);
				int num3 = str.IndexOf("[", StringComparison.Ordinal);
				if ((num3 >= 0) && (num3 < num2))
				{
					int num4 = 1;
					int num5 = str.Length;
					int num6 = num3 + 1;
					while (num6 < num5)
					{
						switch (str[num6])
						{
							case '[':
								num4++;
								goto Label_0082;

							case '\\':
								goto Label_0082;

							case ']':
								break;

							default:
								goto Label_0082;
						}
						num4--;
						Label_0082:
						if (num4 == 0)
						{
							break;
						}
						num6++;
					}
					num2 = str.IndexOf(separator, num6, StringComparison.Ordinal);
				}
				if (num2 < 0)
				{
					num2 = str.Length;
				}
				string text1 = str.Substring(0, num2);
				int num7 = text1.Length;
				if (((num7 > 0) && (text1[0] == '[')) && (text1[num7 - 1] == ']'))
				{
					text1 = text1.Substring(1, num7 - 2);
				}
				list1.Add(text1.Trim());
				if ((num2 + num1) > str.Length)
				{
					str = "";
				}
				else
				{
					str = str.Substring(num2 + num1).Trim();
				}
			}
			Array array1 = Array.CreateInstance(typeof(string), list1.Count);
			list1.CopyTo(array1);
			return array1;
		}


		/// <summary>
		/// 将字符串转换成 Color 对象
		/// </summary>
		/// <param name="str"></param>
		/// <returns></returns>
		public static Color ColorFromStr(string str)
		{
			Color color1 = Color.Black;
			Array array1 = StrToArray(str);
			
			if (array1.Length >= 3)
			{
				int num1 = (int)Utils.ValD((string)array1.GetValue(0));
				int num2 = (int)Utils.ValD((string)array1.GetValue(1));
				int num3 = (int)Utils.ValD((string)array1.GetValue(2));
				color1 = Color.FromArgb(num1, num2, num3);
			}
			return color1;
		}


		/// <summary>
		/// Translate Color to String 
		/// </summary>
		/// <param name="color"></param>
		/// <returns></returns>
		public static string ColorToStr(Color color)
		{
			return (color.R.ToString() + "," + color.G.ToString() + "," + color.B.ToString());
		}

		/// <summary>
		/// 从pcSource 末尾移除 pcRemoveStr
		/// </summary>
		/// <param name="pcSource"></param>
		/// <param name="pcRemoveStr"></param>
		/// <returns></returns>
		public static string TrimEnd(string pcSource, string pcRemoveStr)
		{
			char[] chArray1 = pcRemoveStr.ToCharArray();
			return pcSource.TrimEnd(chArray1);
		}

		/// <summary>
		/// 字符串转换成日期格式
		/// </summary>
		/// <param name="pcStr"></param>
		/// <returns></returns>
		public static DateTime StrToDt(string pcStr)
		{
			DateTime dateTime = new DateTime(1900, 1, 1);
			try
			{
				dateTime= DateTime.Parse(pcStr);
				return dateTime;
			}
			catch (Exception)
			{
				// ignored
			}
			return dateTime;
		}

		/// <summary>
		/// 将 piCount 个 pcString 串成一个字符串
		/// </summary>
		/// <param name="pcString"></param>
		/// <param name="piCount"></param>
		/// <returns></returns>
		public static string Replicate(string pcString, int piCount)
		{
			string text1 = "";
			for (int i = 0; i < piCount; i++)
			{
				text1 = text1 + pcString;
			}
			return text1;
		}


		/// <summary>
		/// Translate RectangleF to string 
		/// </summary>
		/// <param name="rect"></param>
		/// <returns></returns>
		public static string RectToStr(RectangleF rect)
		{
			return (rect.X.ToString(CultureInfo.InvariantCulture) + "," + rect.Y.ToString(CultureInfo.InvariantCulture) + "," + rect.Width.ToString(CultureInfo.InvariantCulture) + "," + rect.Height.ToString(CultureInfo.InvariantCulture));
		}


		/// <summary>
		///  Translate string  to RectangleF
		/// </summary>
		/// <param name="str"></param>
		/// <returns></returns>
		public static RectangleF RectFromStr(string str)
		{
			Array array1 = StrToArray(str);
			RectangleF ef1 = new Rectangle(0, 0, 0, 0);
			if (array1.Length >= 4)
			{
				ef1.X = (float)Utils.ValD((string)array1.GetValue(0));
				ef1.Y = (float)Utils.ValD((string)array1.GetValue(1));
				ef1.Width = (float)Utils.ValD((string)array1.GetValue(2));
				ef1.Height = (float)Utils.ValD((string)array1.GetValue(3));
			}
			return ef1;
		}


		/// <summary>
		/// PrinterSettings To String 
		/// </summary>
		/// <param name="poSetting"></param>
		/// <returns></returns>
		public static string PrinterSettingToStr(PrinterSettings poSetting)
		{
			string text1 = "";
			text1 = AppendToStr(text1, "PrinterName=" + poSetting.PrinterName);
			text1 = AppendToStr(text1, "FromPage=" + poSetting.FromPage.ToString());
			text1 = AppendToStr(text1, "ToPage=" + poSetting.ToPage.ToString());
			return AppendToStr(text1, "Copies=" + poSetting.Copies.ToString());
		}


		/// <summary>
		/// String To PrinterSettings
		/// </summary>
		/// <param name="pcString"></param>
		/// <returns></returns>
		public static PrinterSettings PrinterSettingFromStr(string pcString)
		{
			PrinterSettings settings1 = new PrinterSettings();
			Array array1 = StrToArray(pcString);
			foreach (string text1 in array1)
			{
				Array array2 = StrToArrayEx(text1, "=");
				if (array2.Length == 2)
				{
					
					string text2 = array2.GetValue(0).ToString();
					string text3 = array2.GetValue(1).ToString();
					string text4 = string.IsInterned(text2);
					if (text4 != null)
					{
						//text4 = string.IsInterned(text4);
						if (text4 == "PrinterName")
						{
							settings1.PrinterName = text3;
						}
						else
						{
							if (text4 == "FromPage")
							{
								settings1.FromPage = Utils.ValI(text3);
								continue;
							}
							if (text4 == "ToPage")
							{
								settings1.ToPage = Utils.ValI(text3);
								continue;
							}
							if (text4 == "Copies")
							{
								settings1.Copies = (short)Utils.ValI(text3);
							}
						}
					}
				}
			}
			return settings1;
		}


		public static string PrinterPageSettingToStr(PrinterSettings poPrinter, PageSettings poPage)
		{
			if (poPage == null)
			{
				return ("[" + PrinterSettingToStr(poPrinter) + "],[Default]");
			}
			return ("[" + PrinterSettingToStr(poPrinter) + "],[" + PageSettingToStr(poPage) + "]");
		}



		public static string PageSettingToStr(PageSettings poSetting)
		{
			string text1 = "";
			text1 = AppendToStr(text1, "LeftMargin=" + poSetting.Margins.Left.ToString());
			text1 = AppendToStr(text1, "TopMargin=" + poSetting.Margins.Top.ToString());
			text1 = AppendToStr(text1, "RightMargin=" + poSetting.Margins.Right.ToString());
			text1 = AppendToStr(text1, "BottomMargin=" + poSetting.Margins.Bottom.ToString());
			text1 = AppendToStr(text1, "PaperSize=" + PaperSizeToStr(poSetting.PaperSize));
			text1 = AppendToStr(text1, "Landscape=" + (poSetting.Landscape ? "Yes" : "No"));
			return AppendToStr(text1, "PaperSource=" + poSetting.PaperSource.SourceName);
		}

		public static string PaperSizeToStr(PaperSize poPaper)
		{
			return JoinString(poPaper.Kind.ToString(), poPaper.Width.ToString(), poPaper.Height.ToString());
		}


		/// <summary>
		/// 将 几个对象的字符以 [],[],[],[] 格式连接起来
		/// </summary>
		/// <param name="poFirst"></param>
		/// <param name="poSecond"></param>
		/// <param name="poThird"></param>
		/// <param name="poFourth"></param>
		/// <returns></returns>
		public static string JoinString(object poFirst, object poSecond, object poThird, object poFourth)
		{
			return string.Format("[{0}],[{1}], [{2}], [{3}]", new object[] { poFirst.ToString().Trim(), poSecond.ToString().Trim(), poThird.ToString().Trim(), poFourth.ToString().Trim() });
		}

		/// <summary>
		/// 将 几个对象的字符以 [],[],[],[] 格式连接起来
		/// </summary>
		/// <param name="poFirst"></param>
		/// <param name="poSecond"></param>
		/// <param name="poThird"></param>
		/// <returns></returns>
		public static string JoinString(object poFirst, object poSecond, object poThird)
		{
			return string.Format("[{0}],[{1}], [{2}]", poFirst.ToString().Trim(), poSecond.ToString().Trim(), poThird.ToString().Trim());
		}

		public static string FontToStr(Font font)
		{
			string text1 = "Name:" + font.Name + ",Size:" + font.Size.ToString(CultureInfo.InvariantCulture);
			if (font.Underline)
			{
				text1 = text1 + ",Underline:Y";
			}
			if (font.Italic)
			{
				text1 = text1 + ",Italic:Y";
			}
			if (font.Strikeout)
			{
				text1 = text1 + ",Strikeout:Y";
			}
			if (font.Bold)
			{
				text1 = text1 + ",Bold:Y";
			}
			return text1;
		}

		/// <summary>
		/// 字符串转换成 Font 型
		/// </summary>
		/// <param name="str">传入字符串</param>
		/// <returns>返回的font</returns>
		/// 
		public static Font FontFromStr(string str)
		{
			Array array1 = StrToArray(str);
			Hashtable hashtable1 = new Hashtable();
			for (int num1 = 0; num1 < array1.Length; num1++)
			{
				Array array2 = StrToArrayEx(array1.GetValue(num1).ToString(), ":");
				if (array2.Length == 2)
				{
					hashtable1.Add(array2.GetValue(0), array2.GetValue(1));
				}
			}
			string text1 = FontFamily.GenericSansSerif.Name;
			if (hashtable1.ContainsKey("Name"))
			{
				text1 = hashtable1["Name"].ToString();
			}
			float single1 = 8f;
			if (hashtable1.ContainsKey("Size"))
			{
				single1 = (float)Utils.ValD(hashtable1["Size"].ToString());
			}
			FontStyle style1 = FontStyle.Regular;
			if (hashtable1.ContainsKey("Bold"))
			{
				string text2 = hashtable1["Bold"].ToString();
				if (text2 == "Y")
				{
					style1 |= FontStyle.Bold;
				}
			}
			if (hashtable1.ContainsKey("Italic"))
			{
				string text3 = hashtable1["Italic"].ToString();
				if (text3 == "Y")
				{
					style1 |= FontStyle.Italic;
				}
			}
			if (hashtable1.ContainsKey("Underline"))
			{
				string text4 = hashtable1["Underline"].ToString();
				if (text4 == "Y")
				{
					style1 |= FontStyle.Underline;
				}
			}
			if (hashtable1.ContainsKey("Strikeout"))
			{
				string text5 = hashtable1["Strikeout"].ToString();
				if (text5 == "Y")
				{
					style1 |= FontStyle.Strikeout;
				}
			}
			return new Font(text1, single1, style1);
		}

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

		/// <summary>
		/// 将一个字符串转换成大写
		/// </summary>
		/// <param name="pcStr"></param>
		/// <returns></returns>
		public static string UAndT(string pcStr)
		{
			if (pcStr == null)
			{
				pcStr = "";
			}
			return pcStr.ToUpper().Trim();
		}

		/// <summary>
		///  111,22,333;aaa,vbb,dssa 
		/// </summary>
		/// <param name="pcKeys"></param>
		/// <param name="pcValues"></param>
		/// <returns></returns>
		public static Hashtable StrToHashtable(string pcKeys, string pcValues)
		{
			Hashtable hashtable1 = null;
			Array array1 = StrToArray(pcKeys);
			Array array2 = StrToArray(pcValues);
			if (array1.Length == array2.Length)
			{
				hashtable1 = new Hashtable();
				for (int i = 0; i < array1.Length; i++)
				{
					if (!hashtable1.ContainsKey(UAndT(array1.GetValue(i))))
						hashtable1.Add(UAndT(array1.GetValue(i)), array2.GetValue(i));
				}
			}
			return hashtable1;
		}


		public static Dictionary<string, object> StrToDictionary(string pcKeys, string pcValues)
		{
			Dictionary<string, object> loRetVal = null;
			Array array1 = StrToArray(pcKeys);
			Array array2 = StrToArray(pcValues);
			if (array1.Length == array2.Length)
			{
				loRetVal = new Dictionary<string, object>();
				for (int i = 0; i < array1.Length; i++)
				{
					if (!loRetVal.ContainsKey(UAndT(array1.GetValue(i))))
						loRetVal.Add(UAndT(array1.GetValue(i)), array2.GetValue(i));
				}
			}
			return loRetVal;
		}

		/// <summary>
		/// 如果 传人的字符 为 TRUE、YES 或者 Y ,1 返回 true。
		/// </summary>
		/// <param name="pcStr"></param>
		/// <returns></returns>
		public static bool StrToBool(string pcStr)
		{
			pcStr = UAndT(pcStr);
			if (((pcStr != "TRUE") && (pcStr != "YES")) && (pcStr != "Y") && (pcStr != "1"))
			{
				return false;
			}
			return true;
		}


		public static string GetItemFromStrEx(string pcStr, int piIndex, string separator)
		{
			string lcRetVal = "";
			Array loArr = StrToArrayEx(pcStr, separator);
			if ((piIndex < loArr.Length) && (piIndex >= 0))
			{
				lcRetVal = loArr.GetValue(piIndex).ToString();
			}
			return lcRetVal;
		}

		public static string FormatStr(string pcString)
		{
			return pcString.Replace("[", "").Replace("]", "").Trim();
		}

		public static string StrFromObj(object poObj)
		{
			if (poObj == null)
			{
				return "";
			}
			return poObj.ToString().Trim();
		}

		/// <summary>
		/// 取文本左边内容
		/// </summary>
		/// <param name="str">文本</param>
		/// <param name="s">标识符</param>
		/// <returns>左边内容</returns>
		public static string GetLeft(string str, string s)
		{
			string temp = str.Substring(0, str.IndexOf(s, StringComparison.Ordinal));
			return temp;
		}


		/// <summary>
		/// 取文本右边内容
		/// </summary>
		/// <param name="str">文本</param>
		/// <param name="s">标识符</param>
		/// <returns>右边内容</returns>
		public static string GetRight(string str, string s)
		{
			string temp = str.Substring(str.IndexOf(s, StringComparison.Ordinal), str.Length - str.Substring(0, str.IndexOf(s, StringComparison.Ordinal)).Length);
			return temp;
		}

		/// <summary>
		/// 取文本中间内容
		/// </summary>
		/// <param name="str">原文本</param>
		/// <param name="leftstr">左边文本</param>
		/// <param name="rightstr">右边文本</param>
		/// <returns>返回中间文本内容</returns>
		public static string Between(string str, string leftstr, string rightstr)
		{
			int i = str.IndexOf(leftstr, StringComparison.Ordinal) + leftstr.Length;
			string temp = str.Substring(i, str.IndexOf(rightstr, i, StringComparison.Ordinal) - i);
			return temp;
		}


		/// <summary>
		/// 取文本中间到List集合
		/// </summary>
		/// <param name="str">文本字符串</param>
		/// <param name="leftstr">左边文本</param>
		/// <param name="rightstr">右边文本</param>
		/// <returns>List集合</returns>
		public List<string> BetweenArr(string str, string leftstr, string rightstr)
		{
			List<string> list = new List<string>();
			int leftIndex = str.IndexOf(leftstr, StringComparison.Ordinal);//左文本起始位置
			int leftlength = leftstr.Length;//左文本长度
			while (leftIndex != -1)
			{
				int rightIndex = str.IndexOf(rightstr, leftIndex + leftlength, StringComparison.Ordinal);
				if (rightIndex == -1)
				{
					break;
				}
				string temp = str.Substring(leftIndex + leftlength, rightIndex - leftIndex - leftlength);
				list.Add(temp);
				leftIndex = str.IndexOf(leftstr, rightIndex + 1, StringComparison.Ordinal);
			}
			return list;
		}


		/// <summary>
		/// 指定文本倒序
		/// </summary>
		/// <param name="str">文本</param>
		/// <returns>倒序文本</returns>
		public static string StrReverse(string str)
		{
			char[] chars = str.ToCharArray();
			StringBuilder sb = new StringBuilder();
			for (int i = 0; i < chars.Length; i++)
			{
				sb.Append(chars[chars.Length - 1 - i]);
			}
			return sb.ToString();
		}


		///<summary>
		///得到随机字符.
		///</summary>
		///<param name="intLength">Length of the int.</param>
		///<param name="booNumber">if set to <c>true</c> [boo number].</param>
		///<param name="booSign">if set to <c>true</c> [boo sign].</param>
		///<param name="booSmallword">if set to <c>true</c> [boo smallword].</param>
		///<param name="booBigword">if set to <c>true</c> [boo bigword].</param>
		///<returns></returns>
		public static string GetRandomizer(int intLength, bool booNumber, bool booSign, bool booSmallword, bool booBigword)
		{
			//定义
			Random ranA = new Random();
			int intResultRound = 0;
			string strB = "";
			while (intResultRound < intLength)
			{
				//生成随机数A，表示生成类型
				//1=数字，2=符号，3=小写字母，4=大写字母
				var intA = ranA.Next(1, 5);
				//如果随机数A=1，则运行生成数字
				//生成随机数A，范围在0-10
				//把随机数A，转成字符
				//生成完，位数+1，字符串累加，结束本次循环
				if (intA == 1 && booNumber)
				{
					intA = ranA.Next(0, 10);
					strB = intA + strB;
					intResultRound = intResultRound + 1;
					continue;
				}
				//如果随机数A=2，则运行生成符号
				//生成随机数A，表示生成值域
				//1：33-47值域，2：58-64值域，3：91-96值域，4：123-126值域
				if (intA == 2 && booSign)
				{
					intA = ranA.Next(1, 5);
					//如果A=1
					//生成随机数A，33-47的Ascii码
					//把随机数A，转成字符
					//生成完，位数+1，字符串累加，结束本次循环
					if (intA == 1)
					{
						intA = ranA.Next(33, 48);
						strB = ((char)intA) + strB;
						intResultRound = intResultRound + 1;
						continue;
					}

					//如果A=2
					//生成随机数A，58-64的Ascii码
					//把随机数A，转成字符
					//生成完，位数+1，字符串累加，结束本次循环
					if (intA == 2)
					{
						intA = ranA.Next(58, 65);
						strB = ((char)intA) + strB;
						intResultRound = intResultRound + 1;
						continue;
					}

					//如果A=3
					//生成随机数A，91-96的Ascii码
					//把随机数A，转成字符
					//生成完，位数+1，字符串累加，结束本次循环
					if (intA == 3)
					{
						intA = ranA.Next(91, 97);
						strB = ((char)intA) + strB;
						intResultRound = intResultRound + 1;
						continue;
					}

					//如果A=4
					//生成随机数A，123-126的Ascii码
					//把随机数A，转成字符
					//生成完，位数+1，字符串累加，结束本次循环
					if (intA == 4)
					{
						intA = ranA.Next(123, 127);
						strB = ((char)intA) + strB;
						intResultRound = intResultRound + 1;
						continue;
					}
				}

				//如果随机数A=3，则运行生成小写字母
				//生成随机数A，范围在97-122
				//把随机数A，转成字符
				//生成完，位数+1，字符串累加，结束本次循环
				if (intA == 3 && booSmallword)
				{
					intA = ranA.Next(97, 123);
					strB = ((char)intA) + strB;
					intResultRound = intResultRound + 1;
					continue;
				}

				//如果随机数A=4，则运行生成大写字母
				//生成随机数A，范围在65-90
				//把随机数A，转成字符
				//生成完，位数+1，字符串累加，结束本次循环
				if (intA == 4 && booBigword)
				{
					intA = ranA.Next(65, 89);
					strB = ((char)intA) + strB;
					intResultRound = intResultRound + 1;
				}
			}
			return strB;
		}

		//随机字符串生成器的主要功能如下： 
		//1、支持自定义字符串长度
		//2、支持自定义是否包含数字
		//3、支持自定义是否包含小写字母
		//4、支持自定义是否包含大写字母
		//5、支持自定义是否包含特殊符号
		//6、支持自定义字符集

		///<summary>
		///生成随机字符串
		///</summary>
		///<param name="length">目标字符串的长度</param>
		///<param name="useNum">是否包含数字，1=包含，默认为包含</param>
		///<param name="useLow">是否包含小写字母，1=包含，默认为包含</param>
		///<param name="useUpp">是否包含大写字母，1=包含，默认为包含</param>
		///<param name="useSpe">是否包含特殊字符，1=包含，默认为不包含</param>
		///<param name="custom">要包含的自定义字符，直接输入要包含的字符列表</param>
		///<returns>指定长度的随机字符串</returns>
		public static string GetRnd(int length, bool useNum, bool useLow, bool useUpp, bool useSpe, string custom)
		{
			byte[] b = new byte[4];
			new System.Security.Cryptography.RNGCryptoServiceProvider().GetBytes(b);
			Random r = new Random(BitConverter.ToInt32(b, 0));
			string s = null, str = custom;
			if (useNum) { str += "0123456789"; }
			if (useLow) { str += "abcdefghijklmnopqrstuvwxyz"; }
			if (useUpp) { str += "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; }
			if (useSpe) { str += "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"; }
			for (int i = 0; i < length; i++)
			{
				s += str.Substring(r.Next(0, str.Length - 1), 1);
			}
			return s;
		}

	}

}