转自：http://developer.coreweb.com/articles/Default5.aspx
using System;using System.Collections.Generic;using System.Security.Cryptography;using System.Text;using System.Text.RegularExpressions;using System.Web;using System.Xml;
namespace CoreWebLibrary.String{ /// <summary> /// Helper functions for String not already found in C#. /// Inspired by PHP String Functions that are missing in .Net. /// </summary> public static class StringHelper { /// <summary> /// Base64 encodes a string. /// </summary> /// <param name="input">A string</param> /// <returns>A base64 encoded string</returns> public static string Base64StringEncode(string input) { byte[] encbuff = System.Text.Encoding.UTF8.GetBytes(input); return Convert.ToBase64String(encbuff); }
/// <summary> /// Base64 decodes a string. /// </summary> /// <param name="input">A base64 encoded string</param> /// <returns>A decoded string</returns> public static string Base64StringDecode(string input) { byte[] decbuff = Convert.FromBase64String(input); return System.Text.Encoding.UTF8.GetString(decbuff); }
/// <summary> /// A case insenstive replace function. /// </summary> /// <param name="input">The string to examine.</param> /// <param name="newValue">The value to replace.</param> /// <param name="oldValue">The new value to be inserted</param> /// <returns>A string</returns> public static string CaseInsenstiveReplace(string input, string newValue, string oldValue) { Regex regEx = new Regex(oldValue, RegexOptions.IgnoreCase | RegexOptions.Multiline); return regEx.Replace(input, newValue); }
/// <summary> /// Replaces the first occurence of a string with the replacement value. The Replace /// is case senstive /// </summary> /// <param name="input">The string to examine</param> /// <param name="oldValue">The value to replace</param> /// <param name="newValue">the new value to be inserted</param> /// <returns>A string</returns> public static string ReplaceFirst(string input, string oldValue, string newValue) { Regex regEx = new Regex(oldValue, RegexOptions.Multiline); return regEx.Replace(input, newValue, 1); }
/// <summary> /// Replaces the last occurence of a string with the replacement value. /// The replace is case senstive. /// </summary> /// <param name="input">The string to examine</param> /// <param name="oldValue">The value to replace</param> /// <param name="newValue">the new value to be inserted</param> /// <returns>A string</returns> public static string ReplaceLast(string input, string oldValue, string newValue) { int index = input.LastIndexOf(oldValue); if (index < 0) { return input; } else { StringBuilder sb = new StringBuilder(input.Length - oldValue.Length + newValue.Length); sb.Append(input.Substring(0, index)); sb.Append(newValue); sb.Append(input.Substring(index + oldValue.Length, input.Length - index - oldValue.Length)); return sb.ToString(); } }
/// <summary> /// Removes all the words passed in the filter words /// parameters. The replace is NOT case /// sensitive. /// </summary> /// <param name="input">The string to search.</param> /// <param name="filterWords">The words to /// repace in the input string.</param> /// <returns>A string.</returns> public static string FilterWords(string input, params string[] filterWords) { return StringHelper.FilterWords(input, char.MinValue, filterWords); }
/// <summary> /// Removes all the words passed in the filter words /// parameters. The replace is NOT case /// sensitive. /// </summary> /// <param name="input">The string to search.</param> /// <param name="mask">A character that is inserted for each /// letter of the replaced word.</param> /// <param name="filterWords">The words to // repace in the input string.</param> /// <returns>A string.</returns> public static string FilterWords(string input, char mask, params string[] filterWords) { string stringMask = mask == char.MinValue ? string.Empty : mask.ToString(); string totalMask = stringMask;
foreach (string s in filterWords) { Regex regEx = new Regex(s, RegexOptions.IgnoreCase | RegexOptions.Multiline);
if (stringMask.Length > 0) { for (int i = 1; i < s.Length; i++) totalMask += stringMask; }
input = regEx.Replace(input, totalMask);
totalMask = stringMask; }
return input; }
/// <summary> /// Checks the passed string to see if has any of the /// passed words. Not case-sensitive. /// </summary> /// <param name="input">The string to check.</param> /// <param name="hasWords">The words to check for.</param> /// <returns>A collection of the matched words.</returns> public static MatchCollection HasWords(string input, params string[] hasWords) { StringBuilder sb = new StringBuilder(hasWords.Length + 50); //sb.Append("[");
foreach (string s in hasWords) { sb.AppendFormat("({0})|", StringHelper.HtmlSpecialEntitiesEncode(s.Trim())); }
string pattern = sb.ToString(); pattern = pattern.TrimEnd('|'); // +"]";
Regex regEx = new Regex(pattern, RegexOptions.IgnoreCase | RegexOptions.Multiline); return regEx.Matches(input); }
/// <summary> /// A wrapper around HttpUtility.HtmlEncode /// </summary> /// <param name="input">The string to be encoded</param> /// <returns>An encoded string</returns> public static string HtmlSpecialEntitiesEncode(string input) { return HttpUtility.HtmlEncode(input); }
/// <summary> /// A wrapper around HttpUtility.HtmlDecode /// </summary> /// <param name="input">The string to be decoded</param> /// <returns>The decode string</returns> public static string HtmlSpecialEntitiesDecode(string input) { return HttpUtility.HtmlDecode(input); }
/// <summary> /// MD5 encodes the passed string /// </summary> /// <param name="input">The string to encode.</param> /// <returns>An encoded string.</returns> public static string MD5String(string input) { // Create a new instance of the // MD5CryptoServiceProvider object. MD5 md5Hasher = MD5.Create();
// Convert the input string to a byte // array and compute the hash. byte[] data = md5Hasher.ComputeHash( Encoding.Default.GetBytes(input));
// Create a new Stringbuilder to collect the bytes // and create a string. StringBuilder sBuilder = new StringBuilder();
// Loop through each byte of the hashed data // and format each one as a hexadecimal string. for (int i = 0; i < data.Length; i++) { sBuilder.Append(data[i].ToString("x2")); }
// Return the hexadecimal string. return sBuilder.ToString(); }
/// <summary> /// Verified a string against the passed MD5 hash. /// </summary> /// <param name="input">The string to compare.</param> /// <param name="hash">The hash to compare against.</param> /// <returns>True if the input and the hash /// are the same, false otherwise.</returns> public static bool MD5VerifyString(string input, string hash) { // Hash the input. string hashOfInput = StringHelper.MD5String(input);
// Create a StringComparer an comare the hashes. StringComparer comparer = StringComparer.OrdinalIgnoreCase;
if (0 == comparer.Compare(hashOfInput, hash)) { return true; } else { return false; } }
/// <summary> /// Left pads the passed input using the HTML /// non-breaking string entity ( ) /// for the total number of spaces. /// </summary> /// <param name="input">The string to pad.</param> /// <param name="totalSpaces">The total number /// to pad the string.</param> /// <returns>A padded string.</returns> public static string PadLeftHtmlSpaces(string input, int totalSpaces) { string space = " "; return PadLeft(input, space, totalSpaces * space.Length); }
/// <summary> /// Left pads the passed input using the passed pad string /// for the total number of spaces. It will not /// cut-off the pad even if it /// causes the string to exceed the total width. /// </summary> /// <param name="input">The string to pad.</param> /// <param name="pad">The string to uses as padding.</param> /// <param name="totalSpaces">The total number to /// pad the string.</param> /// <returns>A padded string.</returns> public static string PadLeft(string input, string pad, int totalWidth) { return StringHelper.PadLeft(input, pad, totalWidth, false); }
/// <summary> /// Left pads the passed input using the passed pad string /// for the total number of spaces. It will /// cut-off the pad so that /// the string does not exceed the total width. /// </summary> /// <param name="input">The string to pad.</param> /// <param name="pad">The string to uses as padding.</param> /// <param name="totalSpaces">The total number to /// pad the string.</param> /// <returns>A padded string.</returns> public static string PadLeft(string input, string pad, int totalWidth, bool cutOff) { if (input.Length >= totalWidth) return input;
int padCount = pad.Length; string paddedString = input;
while (paddedString.Length < totalWidth) { paddedString += pad; }
// trim the excess. if (cutOff) paddedString = paddedString.Substring(0, totalWidth);
return paddedString; }
/// <summary> /// Right pads the passed input using the HTML /// non-breaking string entity ( ) /// for the total number of spaces. /// </summary> /// <param name="input">The string to pad.</param> /// <param name="totalSpaces">The total number /// to pad the string.</param> /// <returns>A padded string.</returns> public static string PadRightHtmlSpaces(string input, int totalSpaces) { string space = " "; return PadRight(input, space, totalSpaces * space.Length); }
/// <summary> /// Right pads the passed input using the passed pad string /// for the total number of spaces. It will not /// cut-off the pad even if it /// causes the string to exceed the total width. /// </summary> /// <param name="input">The string to pad.</param> /// <param name="pad">The string to uses as padding.</param> /// <param name="totalSpaces">The total number to /// pad the string.</param> /// <returns>A padded string.</returns> public static string PadRight(string input, string pad, int totalWidth) { return StringHelper.PadRight(input, pad, totalWidth, false); }
/// <summary> /// Right pads the passed input using the passed pad string /// for the total number of spaces. It will cut-off /// the pad so that /// the string does not exceed the total width. /// </summary> /// <param name="input">The string to pad.</param> /// <param name="pad">The string to uses as padding.</param> /// <param name="totalSpaces">The total number to /// pad the string.</param> /// <returns>A padded string.</returns> public static string PadRight(string input, string pad, int totalWidth, bool cutOff) { if (input.Length >= totalWidth) return input;
string paddedString = string.Empty;
while (paddedString.Length < totalWidth - input.Length) { paddedString += pad; }
// trim the excess. if (cutOff) paddedString = paddedString.Substring(0, totalWidth - input.Length);
paddedString += input;
return paddedString; }
/// <summary> /// Removes the new line (\n) and carriage return (\r) symbols. /// </summary> /// <param name="input">The string to search.</param> /// <returns>A string</returns> public static string RemoveNewLines(string input) { return StringHelper.RemoveNewLines(input, false); }
/// <summary> /// Removes the new line (\n) and carriage return /// (\r) symbols. /// </summary> /// <param name="input">The string to search.</param> /// <param name="addSpace">If true, adds a space /// (" ") for each newline and carriage /// return found.</param> /// <returns>A string</returns> public static string RemoveNewLines(string input, bool addSpace) { string replace = string.Empty; if (addSpace) replace = " ";
string pattern = @"[\r|\n]"; Regex regEx = new Regex(pattern, RegexOptions.IgnoreCase | RegexOptions.Multiline);
return regEx.Replace(input, replace); }
/// <summary> /// Reverse a string. /// </summary> /// <param name="input">The string to reverse</param> /// <returns>A string</returns> /// <remarks>Thanks to Alois Kraus for pointing out an issue /// with an earlier version of this method and to Justin Roger's /// site (http://weblogs.asp.net/justin_rogers/archive/2004/06/10/153175.aspx) /// for helping me to improve that previous method.</remarks> public static string Reverse(string input) { char[] reverse = new char[input.Length]; for (int i = 0, k = input.Length - 1; i < input.Length; i++, k--) { if (char.IsSurrogate(input[k])) { reverse[i + 1] = input[k--]; reverse[i++] = input[k]; } else { reverse[i] = input[k]; } } return new System.String(reverse); }
/// <summary> /// Converts a string to sentence case. /// </summary> /// <param name="input">The string to convert.</param> /// <returns>A string</returns> public static string SentenceCase(string input) { if (input.Length < 1) return input;
string sentence = input.ToLower(); return sentence[0].ToString().ToUpper() + sentence.Substring(1); }
/// <summary> /// Converts all spaces to HTML non-breaking spaces /// </summary> /// <param name="input">The string to convert.</param> /// <returns>A string</returns> public static string SpaceToNbsp(string input) { string space = " "; return input.Replace(" ", space); }
/// <summary> /// Removes all HTML tags from the passed string /// </summary> /// <param name="input">The string whose /// values should be replaced.</param> /// <returns>A string.</returns> public static string StripTags(string input) { Regex stripTags = new Regex("<(.|\n)+?>"); return stripTags.Replace(input, ""); }
/// <summary> /// Converts a string to title case. /// </summary> /// <param name="input">The string to convert.</param> /// <returns>A string.</returns> public static string TitleCase(string input) { return TitleCase(input, true); }
/// <summary> /// Converts a string to title case. /// </summary> /// <param name="input">The string to convert.</param> /// <param name="ignoreShortWords">If true, /// does not capitalize words like /// "a", "is", "the", etc.</param> /// <returns>A string.</returns> public static string TitleCase(string input, bool ignoreShortWords) { List<string> ignoreWords = null; if (ignoreShortWords) { //TODO: Add more ignore words? ignoreWords = new List<string>(); ignoreWords.Add("a"); ignoreWords.Add("is"); ignoreWords.Add("was"); ignoreWords.Add("the"); }
string[] tokens = input.Split(' '); StringBuilder sb = new StringBuilder(input.Length); foreach (string s in tokens) { if (ignoreShortWords == true && s != tokens[0] && ignoreWords.Contains(s.ToLower())) { sb.Append(s + " "); } else { sb.Append(s[0].ToString().ToUpper()); sb.Append(s.Substring(1).ToLower()); sb.Append(" "); } }
return sb.ToString().Trim(); }
/// <summary> /// Removes multiple spaces between words /// </summary> /// <param name="input">The string to trim.</param> /// <returns>A string.</returns> public static string TrimIntraWords(string input) { Regex regEx = new Regex(@"[\s]+"); return regEx.Replace(input, " "); }
/// <summary> /// Converts new line(\n) and carriage return(\r) symbols to /// HTML line breaks. /// </summary> /// <param name="input">The string to convert.</param> /// <returns>A string.</returns> public static string NewLineToBreak(string input) { Regex regEx = new Regex(@"[\n|\r]+"); return regEx.Replace(input, "<br />"); }
/// <summary> /// Wraps the passed string at the /// at the next whitespace on or after the /// total charCount has been reached /// for that line. Uses the environment new line /// symbol for the break text. /// </summary> /// <param name="input">The string to wrap.</param> /// <param name="charCount">The number of characters /// per line.</param> /// <returns>A string.</returns> public static string WordWrap(string input, int charCount) { return StringHelper.WordWrap(input, charCount, false, Environment.NewLine); }
/// <summary> /// Wraps the passed string at the total /// number of characters (if cuttOff is true) /// or at the next whitespace (if cutOff is false). /// Uses the environment new line /// symbol for the break text. /// </summary> /// <param name="input">The string to wrap.</param> /// <param name="charCount">The number of characters /// per line.</param> /// <param name="cutOff">If true, will break in /// the middle of a word.</param> /// <returns>A string.</returns> public static string WordWrap(string input, int charCount, bool cutOff) { return StringHelper.WordWrap(input, charCount, cutOff, Environment.NewLine); }
/// <summary> /// Wraps the passed string at the total number /// of characters (if cuttOff is true) /// or at the next whitespace (if cutOff is false). /// Uses the passed breakText /// for lineBreaks. /// </summary> /// <param name="input">The string to wrap.</param> /// <param name="charCount">The number of /// characters per line.</param> /// <param name="cutOff">If true, will break in /// the middle of a word.</param> /// <param name="breakText">The line break text to use.</param> /// <returns>A string.</returns> public static string WordWrap(string input, int charCount, bool cutOff, string breakText) { StringBuilder sb = new StringBuilder(input.Length + 100); int counter = 0;
if (cutOff) { while (counter < input.Length) { if (input.Length > counter + charCount) { sb.Append(input.Substring(counter, charCount)); sb.Append(breakText); } else { sb.Append(input.Substring(counter)); } counter += charCount; } } else { string[] strings = input.Split(' '); for (int i = 0; i < strings.Length; i++) { // added one to represent the space. counter += strings[i].Length + 1; if (i != 0 && counter > charCount) { sb.Append(breakText); counter = 0; }
sb.Append(strings[i] + ' '); } } // to get rid of the extra space at the end. return sb.ToString().TrimEnd(); } }}
转载于:https://www.cnblogs.com/antony1029/archive/2006/11/09/555277.html
相关资源：一个java正则表达式工具类源代码.zip(内含Regexp.java文件)