StringHelp 类，常用字符串操作
using System;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Web;
using System.Xml;
namespace Jiaen.Components.Utility
{
/// <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>
/// 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>
public static string Reverse(string input)
{
if (input.Length <= 1)
return input;
char[] c = input.ToCharArray();
StringBuilder sb = new StringBuilder(c.Length);
for (int i = c.Length - 1; i > -1; i--)
sb.Append(c[i]);
return sb.ToString();
}
/// <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 up the
/// until 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 up the total number of characters (if cuttOff is true)
/// or until 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 up the total number of characters (if cuttOff is true)
/// or until 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++)
{
counter += strings[i].Length + 1; // the added one is to represent the inclusion of the space.
if (i != 0 && counter > charCount)
{
sb.Append(breakText);
counter = 0;
}
sb.Append(strings[i] + ' ');
}
}
return sb.ToString().TrimEnd(); // to get rid of the extra space at the end.
}
/// <summary>
/// 处理null值
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
public static string convertStr(string text)
{
if (text == null)
{
text = "";
}
return text.Trim();
}
/// <summary>
/// 处理长度值
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
public static string subStr(int length,string text)
{
if (text.Length >= length)
{
text = text.Substring(0,length)+" ...";
}
return text;
}
}
}