转自：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();
}
}
}
:
: