C#.net String扩展 SafeSql/UrlEncode/HtmlEncode/FormatWith/正则/ToPinyin/FromJson/验证<收藏>

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Data;
using System.Data.Common;
using System.Web.Script.Serialization;
using System.Text.RegularExpressions;
using System.Web;
using Microsoft.VisualBasic;
using System.Collections;
using System.Xml.Linq;
using System.Xml;
using System.Xml.XPath;
using System.IO;
using System.Drawing;
using System.ComponentModel;

namespace Pub.Class {
public static class StringExtensions {

static public bool IsNullEmpty(this string str) {
return string.IsNullOrEmpty(str);
}
static public string IsNullEmpty(this string str, string defaultValue) {
return str.IsNullEmpty() ? defaultValue : str;
}

static public string SafeSql(this string str) {
str = str.IsNullEmpty() ? "" : str.Replace("'", "''");
str = new Regex("exec", RegexOptions.IgnoreCase).Replace(str, "exec");
str = new Regex("xp_cmdshell", RegexOptions.IgnoreCase).Replace(str, "xp_cmdshell");
str = new Regex("select", RegexOptions.IgnoreCase).Replace(str, "select");
str = new Regex("insert", RegexOptions.IgnoreCase).Replace(str, "insert");
str = new Regex("update", RegexOptions.IgnoreCase).Replace(str, "update");
str = new Regex("delete", RegexOptions.IgnoreCase).Replace(str, "delete");

str = new Regex("drop", RegexOptions.IgnoreCase).Replace(str, "drop");
str = new Regex("create", RegexOptions.IgnoreCase).Replace(str, "create");
str = new Regex("rename", RegexOptions.IgnoreCase).Replace(str, "rename");
str = new Regex("truncate", RegexOptions.IgnoreCase).Replace(str, "truncate");
str = new Regex("alter", RegexOptions.IgnoreCase).Replace(str, "alter");
str = new Regex("exists", RegexOptions.IgnoreCase).Replace(str, "exists");
str = new Regex("master.", RegexOptions.IgnoreCase).Replace(str, "master.");
str = new Regex("restore", RegexOptions.IgnoreCase).Replace(str, "restore");
return str;
}
static public string SafeSqlSimple(this string str) {
str = str.IsNullEmpty() ? "" : str.Replace("'", "''");
return str;
}

public static string UnHtml(this string htmlStr) {
if (htmlStr.IsNullEmpty()) return string.Empty;
return htmlStr.Replace("\"", "\\\"").ShowXmlHtml().Replace(" ", "&nbsp;").Replace("\n", "<br />");
}
public static string ShowXmlHtml(this string htmlStr) {
if (htmlStr.IsNullEmpty()) return string.Empty;
string str = htmlStr.Replace("&", "&amp;").Replace(">", "&gt;").Replace("<", "&lt;");
return str;
}
public static string ShowHtml(this string htmlStr) {
if (htmlStr.IsNullEmpty()) return string.Empty;
string str = htmlStr;

str = Regex.Replace(str, @"(script|frame|form|meta|behavior|style)([\s|:|>])+", "_$1.$2", RegexOptions.IgnoreCase);
str = new Regex("<script", RegexOptions.IgnoreCase).Replace(str, "<_script");
str = new Regex("<object", RegexOptions.IgnoreCase).Replace(str, "<_object");
str = new Regex("javascript:", RegexOptions.IgnoreCase).Replace(str, "_javascript:");
str = new Regex("vbscript:", RegexOptions.IgnoreCase).Replace(str, "_vbscript:");
str = new Regex("expression", RegexOptions.IgnoreCase).Replace(str, "_expression");
str = new Regex("@import", RegexOptions.IgnoreCase).Replace(str, "_@import");
str = new Regex("<iframe", RegexOptions.IgnoreCase).Replace(str, "<_iframe");
str = new Regex("<frameset", RegexOptions.IgnoreCase).Replace(str, "<_frameset");
str = Regex.Replace(str, @"(\<|\s+)o([a-z]+\s?=)", "$1_o$2", RegexOptions.IgnoreCase);
str = new Regex(@" (on[a-zA-Z ]+)=", RegexOptions.IgnoreCase).Replace(str, " _$1=");
return str;
}

public static string UrlEncode(this string str) {
return HttpUtility.UrlEncode(str);
}
public static string UrlDecode(this string str) {
return HttpUtility.UrlDecode(str);
}
public static string HtmlEncode(this string str) {
return HttpUtility.HtmlEncode(str);
}
public static string HtmlDecode(this string str) {
return HttpUtility.HtmlDecode(str);
}

public static int CnLength(this string str) {
return Encoding.Default.GetBytes(str).Length;
}
public static string SubString(this string strInput, int len, string flg) {
string myResult = string.Empty;
if (len >= 0) {
byte[] bsSrcString = Encoding.Default.GetBytes(strInput);
if (bsSrcString.Length > len) {
int nRealLength = len;
int[] anResultFlag = new int[len];
byte[] bsResult = null;

int nFlag = 0;
for (int i = 0; i < len; i++) {
if (bsSrcString[i] > 127) {
nFlag++;
if (nFlag == 3) nFlag = 1;
}
else nFlag = 0;
anResultFlag[i] = nFlag;
}
if ((bsSrcString[len - 1] > 127) && (anResultFlag[len - 1] == 1))
nRealLength = len + 1;
bsResult = new byte[nRealLength];
Array.Copy(bsSrcString, bsResult, nRealLength);
myResult = Encoding.Default.GetString(bsResult);
myResult = myResult + (len >= strInput.CnLength() ? "" : flg);
}
else myResult = strInput;
}
return myResult;
}

public static string GetFileExtends(this string filename) {
string ext = null;
if (filename.IndexOf('.') > 0) {
string[] fs = filename.Split('.');
ext = fs[fs.Length - 1];
}
return ext;
}
public static string GetUrlFileName(this string url) {
if (url == null) return "";
string[] strs1 = url.Split(new char[]{'/'});
return strs1[strs1.Length - 1].Split(new char[]{'?'})[0];
}
public static IList<string> GetHref(this string HtmlCode) {
IList<string> MatchVale = new List<string>();
string Reg = @"(h|H)(r|R)(e|E)(f|F) *= *('|"")?((\w|\\|\/|\.|:|-|_)+)('|""| *|>)?";
foreach (Match m in Regex.Matches(HtmlCode, Reg)) {
MatchVale.Add((m.Value).ToLower().Replace("href=", "").Trim().TrimEnd('\'').TrimEnd('"').TrimStart('\'').TrimStart('"'));
}
return MatchVale;
}
public static IList<string> GetSrc(this string HtmlCode) {
IList<string> MatchVale = new List<string>();
string Reg = @"(s|S)(r|R)(c|C) *= *('|"")?((\w|\\|\/|\.|:|-|_)+)('|""| *|>)?";
foreach (Match m in Regex.Matches(HtmlCode, Reg)) {
MatchVale.Add((m.Value).ToLower().Replace("src=", "").Trim().TrimEnd('\'').TrimEnd('"').TrimStart('\'').TrimStart('"'));
}
return MatchVale;
}
public static string GetEmailHostName(this string strEmail) {
if (strEmail.IndexOf("@") < 0) return "";
return strEmail.Substring(strEmail.LastIndexOf("@")).ToLower();
}

public static DateTime ToDateTime(this string DateTimeStr) {
return DateTime.Parse(DateTimeStr);
}
public static string ToDateTime(this string fDateTime, string formatStr) {
DateTime s = Convert.ToDateTime(fDateTime);
return s.ToString(formatStr);
}
public static DateTime ToDateTime(this string DateTimeStr, DateTime defDate) {
DateTime.TryParse(DateTimeStr,out defDate);
return defDate;
}
public static DateTime? ToDateTime(this string DateTimeStr, DateTime? defDate) {
DateTime dt = DateTime.Now;
DateTime dt2 = dt;
DateTime.TryParse(DateTimeStr,out dt);
if (dt == dt2) return defDate;
return dt;
}

public static byte[] ToBytes(this string value) {
return value.ToBytes(null);
}
public static byte[] ToBytes(this string value, Encoding encoding) {
encoding = (encoding ?? Encoding.Default);
return encoding.GetBytes(value);
}

public static string RemoveHTML(this string HtmlCode) {
string MatchVale = HtmlCode;
MatchVale = new Regex("<br>", RegexOptions.IgnoreCase).Replace(MatchVale, "\n");
foreach (Match s in Regex.Matches(HtmlCode, "<[^{><}]*>")) { MatchVale = MatchVale.Replace(s.Value, ""); }//"(<[^{><}]*>)"//@"<[\s\S-! ]*?>"//"<.+?>"//<(.*)>.*<\/\1>|<(.*) \/>//<[^>]+>//<(.|\n)+?>
MatchVale = new Regex("\n", RegexOptions.IgnoreCase).Replace(MatchVale, "<br>");
return MatchVale;
}
public static string RemoveAllHTML(this string content) {
string pattern = "<[^>]*>";
return Regex.Replace(content, pattern, string.Empty, RegexOptions.IgnoreCase);
}

public static string ToSChinese(this string str) {
return Strings.StrConv(str, VbStrConv.SimplifiedChinese, 0) ;
}
public static string ToTChinese(this string str) {
return Strings.StrConv(str, VbStrConv.TraditionalChinese, 0);
}

public static double Evel(this string ExprStr) {
Expression expression = new Expression("return " + ExprStr + ";");
return expression.Compute(0);
}
public static string Reverse(this string value) {
if (value.IsNullEmpty()) return string.Empty;

var chars = value.ToCharArray();
Array.Reverse(chars);
return new string(chars);
}

public static string UBB(this string chr) {
if (chr.IsNullEmpty()) return string.Empty;
chr = chr.HtmlEncode();
chr = Regex.Replace(chr, @"<script(?<x>[^\>]*)>(?<y>[^\>]*) \</script\>", @"&lt;script$1&gt;$2&lt;/script&gt;", RegexOptions.IgnoreCase);
chr = Regex.Replace(chr, @"\[url=(?<x>[^\]]*)\](?<y>[^\]]*)\[/url\]", @"<a href=$1 target=_blank>$2</a>", RegexOptions.IgnoreCase);
chr = Regex.Replace(chr, @"\[url\](?<x>[^\]]*)\[/url\]", @"<a href=$1 target=_blank>$1</a>", RegexOptions.IgnoreCase);

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

chr = Regex.Replace(chr, @"\[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);
chr = Regex.Replace(chr, @"\", @"<IMG SRC=""$1"" border=0>", RegexOptions.IgnoreCase);

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

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

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

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

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

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

chr = Regex.Replace(chr, @"\[list\](?<x>[^\]]*)\[/list\]", @"<ul>$1</ul>", RegexOptions.IgnoreCase);
chr = Regex.Replace(chr, @"\[list=1\](?<x>[^\]]*)\[/list\]", @"<ol type=1>$1</ol id=1>", RegexOptions.IgnoreCase);
chr = Regex.Replace(chr, @"\[list=a\](?<x>[^\]]*)\[/list\]", @"<ol type=a>$1</ol id=a>", RegexOptions.IgnoreCase);
chr = Regex.Replace(chr, @"\[\*\](?<x>[^\]]*)\[/\*\]", @"<li>$1</li>", RegexOptions.IgnoreCase);
chr = Regex.Replace(chr, @"\[quote](?<x>.*)\[/quote]", @"<center>—— 以下是引用 ——<table border='1' width='80%' cellpadding='10' cellspacing='0' ><tr><td>$1</td></tr></table></center>", RegexOptions.IgnoreCase);
return (chr);
}

public static string FormatWith(this string str, params object[] args) {
return string.Format(str, args);
}
public static string FormatWith(this string text, object arg0) {
return string.Format(text, arg0);
}
public static string FormatWith(this string text, object arg0, object arg1) {
return string.Format(text, arg0, arg1);
}
public static string FormatWith(this string text, object arg0, object arg1, object arg2) {
return string.Format(text, arg0, arg1, arg2);
}
public static string FormatWith(this string text, IFormatProvider provider, params object[] args) {
return string.Format(provider, text, args);
}

public static string ReplaceWith(this string value, string regexPattern, string replaceValue) {
return ReplaceWith(value, regexPattern, replaceValue, RegexOptions.None);
}
public static string ReplaceWith(this string value, string regexPattern, string replaceValue, RegexOptions options) {
return Regex.Replace(value, regexPattern, replaceValue, options);
}
public static string ReplaceWith(this string value, string regexPattern, MatchEvaluator evaluator) {
return ReplaceWith(value, regexPattern, RegexOptions.None, evaluator);
}
public static string ReplaceWith(this string value, string regexPattern, RegexOptions options, MatchEvaluator evaluator) {
return Regex.Replace(value, regexPattern, evaluator, options);
}
public static string ReplaceWith(this string value, string regexPattern,string ReplaceString, bool IsCaseInsensetive) {
return Regex.Replace(value, regexPattern, ReplaceString, IsCaseInsensetive ? RegexOptions.IgnoreCase : RegexOptions.None);
}
public static string Replace(this string RegValue, string regStart, string regEnd) {
string s = RegValue;
if (RegValue != "" && RegValue != null) {
if (regStart != "" && regStart != null) { s = s.Replace(regStart, ""); }
if (regEnd != "" && regEnd != null) { s = s.Replace(regEnd, ""); }
}
return s;
}

public static MatchCollection GetMatches(this string value, string regexPattern) {
return GetMatches(value, regexPattern, RegexOptions.None);
}
public static MatchCollection GetMatches(this string value, string regexPattern, RegexOptions options) {
return Regex.Matches(value, regexPattern, options);
}
public static MatchCollection FindBetween(this string s, string startString, string endString) {
return s.FindBetween(startString, endString, true);
}
public static MatchCollection FindBetween(this string s, string startString, string endString, bool recursive) {
MatchCollection matches;

startString = Regex.Escape(startString);
endString = Regex.Escape(endString);

Regex regex = new Regex("(?<=" + startString + ").*(?=" + endString + ")");

matches = regex.Matches(s);

if (!recursive) return matches;

if (matches.Count > 0) {
if (matches[0].ToString().IndexOf(Regex.Unescape(startString)) > -1) {
s = matches[0].ToString() + Regex.Unescape(endString);
return s.FindBetween(Regex.Unescape(startString), Regex.Unescape(endString));
} else {
return matches;
}
} else {
return matches;
}
}

public static IEnumerable<string> GetMatchingValues(this string value, string regexPattern) {
return GetMatchingValues(value, regexPattern, RegexOptions.None);
}
public static IEnumerable<string> GetMatchingValues(this string value, string regexPattern, RegexOptions options) {
foreach(Match match in GetMatches(value, regexPattern, options)) {
if(match.Success) yield return match.Value;
}
}
public static IList<string> GetMatchingValues(this string value, string regexPattern,string rep1, string rep2) {
IList<string> txtTextArr = new List<string>();
string MatchVale = "";
foreach (Match m in Regex.Matches(value, regexPattern)) {
MatchVale = m.Value.Trim().Replace(rep1, "").Replace(rep2, "");
txtTextArr.Add(MatchVale);
}
return txtTextArr;
}

public static string[] Split(this string value, string regexPattern, RegexOptions options) {
return Regex.Split(value, regexPattern, options);
}
public static string[] Split(this string value, string regexPattern) {
return value.Split(regexPattern, RegexOptions.None);
}

public static XDocument ToXDocument(this string xml) {
return XDocument.Parse(xml);
}
public static XmlDocument ToXmlDOM(this string xml) {
var document = new XmlDocument();
document.LoadXml(xml);
return document;
}
public static XPathNavigator ToXPath(this string xml) {
var document = new XPathDocument(new StringReader(xml));
return document.CreateNavigator();
}

public static string ToPinyin(this string s) {
return PinYin.Instance().Search(s).ToLower();
}
public static string ToPinyinChar(this string s) {
string strVal = PinYin.Instance().SearchCap(s);
if (strVal.ToLower() == strVal.ToUpper()) return "*"; else return strVal.ToLower();
}

public static string Left(this string @string, int length) {
if (length <= 0 || @string.Length == 0) return string.Empty;
if (@string.Length <= length) return @string;
return @string.Substring(0, length);
}
public static string Right(this string @string, int length) {
if (length <= 0 || @string.Length == 0) return string.Empty;
if (@string.Length <= length) return @string;
return @string.Substring(@string.Length - length, length);
}

public static T CreateType<T>(this string typeName, params object[] args) {
Type type = Type.GetType(typeName, true, true);
return (T)Activator.CreateInstance(type, args);
}
public static T ToEnum<T>(this string value) {
return ToEnum<T>(value, false);
}
public static T ToEnum<T>(this string value,bool ignorecase) {
if (value == null) throw new ArgumentNullException("Value");
value = value.Trim();
if (value.Length == 0) throw new ArgumentNullException("Must specify valid information for parsing in the string.", "value");
Type t = typeof(T);
if (!t.IsEnum) throw new ArgumentException("Type provided must be an Enum.", "T");
return (T)Enum.Parse(t, value, ignorecase);
}

public static int CharacterCount(this string value, char character) {
int intReturnValue = 0;

for (int intCharacter = 0; intCharacter <= (value.Length - 1); intCharacter++) {
if (value.Substring(intCharacter, 1) == character.ToString()) intReturnValue += 1;
}

return intReturnValue;
}

public static string ForcePrefix(this string s, string prefix) {
string result = s;
if (!result.StartsWith(prefix)) result = prefix + result;
return result;
}
public static string ForceSuffix(this string s, string suffix) {
string result = s;
if (!result.EndsWith(suffix)) result += suffix;
return result;
}
public static string RemovePrefix(this string s, string prefix) {
return Regex.Replace(s, "^" + prefix, System.String.Empty, RegexOptions.IgnoreCase);
}
public static string RemoveSuffix(this string s, string suffix) {
return Regex.Replace(s, suffix + "$", System.String.Empty, RegexOptions.IgnoreCase);
}

public static string PadLeft(this string s, string pad) {
return s.PadLeft(pad, s.Length + pad.Length, false);
}
public static string PadLeft(this string s, string pad, int totalWidth, bool cutOff) {
if (s.Length >= totalWidth) return s;

int padCount = pad.Length;

string paddedString = s;

while (paddedString.Length < totalWidth) paddedString += pad;

if (cutOff) paddedString = paddedString.Substring(0, totalWidth);

return paddedString;
}
public static string PadRight(this string s, string pad) {
return PadRight(s, pad, s.Length + pad.Length, false);
}
public static string PadRight(this string s, string pad, int length, bool cutOff) {
if (s.Length >= length) return s;

string paddedString = string.Empty;

while (paddedString.Length < length - s.Length) paddedString += pad;

if (cutOff) paddedString = paddedString.Substring(0, length - s.Length);

paddedString += s;

return paddedString;
}
public static Color ToColor(this string s) {
s = s.Replace("#", string.Empty);

byte a = System.Convert.ToByte("ff", 16);

byte pos = 0;

if (s.Length == 8) {
a = System.Convert.ToByte(s.Substring(pos, 2), 16);
pos = 2;
}

byte r = System.Convert.ToByte(s.Substring(pos, 2), 16);

pos += 2;

byte g = System.Convert.ToByte(s.Substring(pos, 2), 16);

pos += 2;

byte b = System.Convert.ToByte(s.Substring(pos, 2), 16);

return Color.FromArgb(a, r, g, b);
}

public static bool ContainsArray(this string value, params string[] keywords) {
return keywords.All((s) => value.Contains(s));
}
public static Nullable<T> ToNullable<T>(this string s) where T : struct {
T? result = null;
if (!s.Trim().IsNullEmpty()) {
TypeConverter converter = TypeDescriptor.GetConverter(typeof(T?));
result = (T?)converter.ConvertFrom(s);
}
return result;
}

public static List<string> GetLines(this string text) {
return text.Split(new[] {Environment.NewLine}, StringSplitOptions.None).ToList();
}

public static bool IsMatch(this string str, string op) {
if (str.Equals(String.Empty) || str == null) return false;
Regex re = new Regex(op, RegexOptions.IgnoreCase);
return re.IsMatch(str);
}
public static bool IsIP(this string input) {
return input.IsMatch(@"^((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)$"); //@"^(([01]?[\d]{1,2})|(2[0-4][\d])|(25[0-5]))(\.(([01]?[\d]{1,2})|(2[0-4][\d])|(25[0-5]))){3}$";
}
public static bool IsIPSect(this string ip) {
return ip.IsMatch(@"^((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){2}((2[0-4]\d|25[0-5]|[01]?\d\d?|\*)\.)(2[0-4]\d|25[0-5]|[01]?\d\d?|\*)$");
}
public static bool IsNumber(this string strNumber)
{
string pet = @"^([0-9])[0-9]*(\.\w*)?$";
return strNumber.IsMatch(pet);
}
public static bool IsDouble(this string input) {
string pet = @"^[0-9]*[1-9][0-9]*$";//@"^\d{1,}$"//整数校验常量//@"^-?(0|\d+)(\.\d+)?$"//数值校验常量
return input.IsMatch(pet);
}
public static bool IsInt(this string input) {
string pet = @"^[0-9]*$"; //@"^([0-9])[0-9]*(\.\w*)?$";
return input.IsMatch(pet);
}
public static bool IsNumberArray(this string[] strNumber) {
if (strNumber == null) return false;
if (strNumber.Length < 1) return false;
foreach (string id in strNumber)
if (!id.IsNumber()) return false;
return true;
}
public static bool IsEmail(this string input) {
string pet = @"^([\w-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([\w-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$";//@"^\w+((-\w+)|(\.\w+))*\@\w+((\.|-)\w+)*\.\w+$";
return input.IsMatch(pet);
}
public static bool IsUrl(this string input) {
string pet = @"^(http|https)\://([a-zA-Z0-9\.\-]+(\:[a-zA-Z0-9\.&%\$\-]+)*@)*((25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9])\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[0-9])|localhost|([a-zA-Z0-9\-]+\.)*[a-zA-Z0-9\-]+\.(com|edu|gov|int|mil|net|org|biz|arpa|info|name|pro|aero|coop|museum|[a-zA-Z]{1,10}))(\:[0-9]+)*(/($|[a-zA-Z0-9\.\,\?\'\\\+&%\$#\=~_\-]+))*$";//@"^http://([\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?";
return input.IsMatch(pet);
}
public static bool IsZip(this string input) {
return input.IsMatch(@"\d{6}");
}
public static bool IsSSN(this string input) {
string pet = @"\d{18}|\d{15}";
return input.IsMatch(pet);
}
public static bool IsSafeSqlString(this string str) {
return !Regex.IsMatch(str, @"[-|;|,|\/|\(|\)|\[|\]|\}|\{|%|@|\*|!|\']");
}
public static bool IsDateTime(this string input) {
//string pet = @"^(?:(?:(?:(?:1[6-9]|[2-9]\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00)))(\/|-|\.)(?:0?2\1(?:29))$)|(?:(?:1[6-9]|[2-9]\d)?\d{2})(\/|-|\.)(?:(?:(?:0?[13578]|1[02])\2(?:31))|(?:(?:0?[1,3-9]|1[0-2])\2(29|30))|(?:(?:0?[1-9])|(?:1[0-2]))\2(?:0?[1-9]|1\d|2[0-8]))$";
string pet = @"^(?=\d)(?:(?!(?:1582(?:\.|-|\/)10(?:\.|-|\/)(?:0?[5-9]|1[0-4]))|(?:1752(?:\.|-|\/)0?9(?:\.|-|\/)(?:0?[3-9]|1[0-3])))(?=(?:(?!000[04]|(?:(?:1[^0-6]|[2468][^048]|[3579][^26])00))(?:(?:\d\d)(?:[02468][048]|[13579][26]))\D0?2\D29)|(?:\d{4}\D(?!(?:0?[2469]|11)\D31)(?!0?2(?:\.|-|\/)(?:29|30))))(\d{4})([-\/.])(0?\d|1[012])\2((?!00)[012]?\d|3[01])(?:$|(?=\x20\d)\x20))?((?:(?:0?[1-9]|1[012])(?::[0-5]\d){0,2}(?:\x20[aApP][mM]))|(?:[01]?\d|2[0-3])(?::[0-5]\d){1,2})?$";
return input.IsMatch(pet);
}
public static bool IsDateTime2(this string DateTimeStr) {
try { DateTime _dt = DateTime.Parse(DateTimeStr); return true; } catch { return false; }
}
public static bool IsDate(this string DateStr) {
try { DateTime _dt = DateTime.Parse(DateStr); return true; } catch { return false; }
}
public static bool IsTime(this string TimeStr) {
return TimeStr.IsMatch(@"^([0-1]\\d|2[0-3]):[0-5]\\d:[0-5]\\d$");//^((([0-1]?[0-9])|(2[0-3])):([0-5]?[0-9])(:[0-5]?[0-9])?)$
}
public static bool IsAlphaNumeric(this string input) {
return input.IsMatch(@"[^a-zA-Z0-9]");
}
public static bool IsTelepone(this string input) {
return input.IsMatch(@"^[+]{0,1}(\d){1,3}[ ]?([-]?((\d)|[ ]){1,12})+$");//："^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$
}
public static bool IsMobile(this string input) {
return input.IsMatch(@"^[+]{0,1}(\d){1,3}[ ]?([-]?((\d)|[ ]){1,12})+$");
}
public static bool IsInArray(this string stringarray, string str) {
return stringarray.Split(",").IsInArray(str, false);
}
public static bool IsInArray(this string stringarray, string str, string strsplit) {
return stringarray.Split(strsplit).IsInArray(str, false);
}
public static bool IsInArray(this string stringarray, string str, string strsplit, bool caseInsensetive) {
return stringarray.Split(strsplit).IsInArray(str, caseInsensetive);
}
public static bool IsBase64String(this string str) {
return Regex.IsMatch(str, @"[A-Za-z0-9\+\/\=]");
}
public static bool IsYear(this string input) {
return Regex.IsMatch(input, @"^(19\d\d)|(200\d)$");
}
public static bool IsImgFileName(this string filename) {
filename = filename.Trim();
if (filename.EndsWith(".") || (filename.IndexOf(".") == -1)) return false;
string str = filename.Substring(filename.LastIndexOf(".") + 1).ToLower();
if (((str != "jpg") && (str != "jpeg")) && ((str != "png") && (str != "bmp"))) return (str == "gif");
return true;
}
public static bool IsGuid(this string s) {
if (s.IsNullEmpty()) return false;
Regex format = new Regex("^[A-Fa-f0-9]{32}$|" +
"^({|\\()?[A-Fa-f0-9]{8}-([A-Fa-f0-9]{4}-){3}[A-Fa-f0-9]{12}(}|\\))?$|" +
"^({)?[0xA-Fa-f0-9]{3,10}(, {0,1}[0xA-Fa-f0-9]{3,6}){2},{0,1}({)([0xA-Fa-f0-9]{3,4}, {0,1}){7}[0xA-Fa-f0-9]{3,4}(}})$");
Match match = format.Match(s);
return match.Success;
}

public static string GetMapPath(this string strPath) {
if(HttpContext.Current != null)
return HttpContext.Current.Server.MapPath(strPath);
else
return System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, strPath);
}

public static Guid ToGuid(this string target) {
if ((!target.IsNullEmpty()) && (target.Trim().Length == 22)) {
string encoded = string.Concat(target.Trim().Replace("-", "+").Replace("_", "/"), "==");
byte[] base64 = Convert.FromBase64String(encoded);
return new Guid(base64);
}
return Guid.Empty;
}

public static T FromJson<T>(this string json) {
JavaScriptSerializer jsonSerializer = new JavaScriptSerializer();
return jsonSerializer.Deserialize<T>(json);
}
}
}