Best String Extension Methods
public static class StringExtensions
{
///
/// if the string is NULL, converts it to string.empty. Helpful when trying to avoid null conditions.
///
///
///
public static string IsNullThenEmpty(this string inString)
{
if (inString == null)
return string.Empty;
else
return inString;
}
public static string[] GetStringInBetween(this string strSource, string strBegin, string strEnd, bool includeBegin, bool includeEnd)
{
string[] result = { "", "" };
int iIndexOfBegin = strSource.IndexOf(strBegin);
if (iIndexOfBegin != -1)
{
// include the Begin string if desired
if (includeBegin)
iIndexOfBegin -= strBegin.Length;
strSource = strSource.Substring(iIndexOfBegin
+ strBegin.Length);
int iEnd = strSource.IndexOf(strEnd);
if (iEnd != -1)
{
// include the End string if desired
if (includeEnd)
iEnd += strEnd.Length;
result[0] = strSource.Substring(0, iEnd);
// advance beyond this segment
if (iEnd + strEnd.Length < strSource.Length)
result[1] = strSource.Substring(iEnd
+ strEnd.Length);
}
}
else
// stay where we are
result[1] = strSource;
return result;
}
public static T ToEnum(this string value)
where T : struct
{
//Debug.Assert(!string.IsNullOrEmpty(value));
return (T)Enum.Parse(typeof(T), value, true);
}
public static string Nl2Br(this string s)
{
return s.Replace("\r\n", "
").Replace("\n", "
");
}
public static string Format(this string format, object arg, params object[] additionalArgs)
{
if (additionalArgs == null || additionalArgs.Length == 0)
{
return string.Format(format, arg);
}
else
{
return string.Format(format, new object[] { arg }.Concat(additionalArgs).ToArray());
}
}
public static bool ContainsAny(this string theString, char[] characters)
{
foreach (char character in characters)
{
if (theString.Contains(character.ToString()))
{
return true;
}
}
return false;
}
///
/// Strip a string of the specified substring.
///
/// the string to process
/// substring to remove
///
/// string s = "abcde";
///
/// s = s.Strip("bcd"); //s becomes 'ae;
///
///
public static string Strip(this string s, string subString)
{
s = s.Replace(subString, "");
return s;
}
///
/// Strip a string of the specified character.
///
/// the string to process
/// character to remove from the string
///
/// string s = "abcde";
///
/// s = s.Strip('b'); //s becomes 'acde;
///
///
public static string Strip(this string s, char character)
{
s = s.Replace(character.ToString(), "");
return s;
}
///
/// Strip a string of the specified characters.
///
/// the string to process
/// list of characters to remove from the string
///
/// string s = "abcde";
///
/// s = s.Strip('a', 'd'); //s becomes 'bce;
///
///
public static string Strip(this string s, params char[] chars)
{
foreach (char c in chars)
{
s = s.Replace(c.ToString(), "");
}
return s;
}
///
/// Splits a string into a NameValueCollection, where each "namevalue" is separated by
/// the "OuterSeparator". The parameter "NameValueSeparator" sets the split between Name and Value.
/// Example:
/// String str = "param1=value1;param2=value2";
/// NameValueCollection nvOut = str.ToNameValueCollection(';', '=');
///
/// The result is a NameValueCollection where:
/// key[0] is "param1" and value[0] is "value1"
/// key[1] is "param2" and value[1] is "value2"
///
/// String to process
/// Separator for each "NameValue"
/// Separator for Name/Value splitting
///
public static NameValueCollection ToNameValueCollection(this String str, Char OuterSeparator, Char NameValueSeparator)
{
NameValueCollection nvText = null;
str = str.TrimEnd(OuterSeparator);
if (!String.IsNullOrEmpty(str))
{
String[] arrStrings = str.TrimEnd(OuterSeparator).Split(OuterSeparator);
foreach (String s in arrStrings)
{
Int32 posSep = s.IndexOf(NameValueSeparator);
String name = s.Substring(0, posSep);
String value = s.Substring(posSep + 1);
if (nvText == null)
nvText = new NameValueCollection();
nvText.Add(name, value);
}
}
return nvText;
}
///
/// Truncates the string to a specified length and replace the truncated to a ...
///
/// string that will be truncated
/// total length of characters to maintain before the truncate happens
/// truncated string
public static string Truncate(this string text, int maxLength)
{
// replaces the truncated string to a ...
const string suffix = "...";
string truncatedString = text;
if (maxLength <= 0) return truncatedString;
int strLength = maxLength - suffix.Length;
if (strLength <= 0) return truncatedString;
if (text == null || text.Length <= maxLength) return truncatedString;
truncatedString = text.Substring(0, strLength);
truncatedString = truncatedString.TrimEnd();
truncatedString += suffix;
return truncatedString;
}
///
/// Returns the last few characters of the string with a length
/// specified by the given parameter. If the string's length is less than the
/// given length the complete string is returned. If length is zero or
/// less an empty string is returned
///
/// the string to process
/// Number of characters to return
///
public static string Right(this string s, int length)
{
length = Math.Max(length, 0);
if (s.Length > length)
{
return s.Substring(s.Length - length, length);
}
else
{
return s;
}
}
public static String left(this String s, int len)
{
return s.Substring(0, Math.Min(len, s.Length));
}
public static DateTime ToDateFromDDMMYYYY(this string date)
{
return DateTime.ParseExact(date, "dd/MM/yyyy", System.Globalization.CultureInfo.InvariantCulture);
}
//Format string to Title case
public static string ToTitleCase(this string mText)
{
if (mText == null) return mText;
System.Globalization.CultureInfo cultureInfo = System.Threading.Thread.CurrentThread.CurrentCulture;
System.Globalization.TextInfo textInfo = cultureInfo.TextInfo;
// TextInfo.ToTitleCase only operates on the string if is all lower case, otherwise it returns the string unchanged.
return textInfo.ToTitleCase(mText.ToLower());
}
///
/// Parses a string into an Enum
///
/// The type of the Enum
/// String value to parse
/// The Enum corresponding to the stringExtensions
public static T EnumParse(this string value)
{
return EnumParse(value, false);
}
public static T EnumParse(this string value, bool ignorecase)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
value = value.Trim();
if (value.Length == 0)
{
throw new ArgumentException("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);
}
// Enable quick and more natural string.Format calls
public static string F(this string s, params object[] args)
{
return string.Format(s, args);
}
public static DateTime? ToDateTime(this string source)
{
if (!string.IsNullOrEmpty(source))
{
return Convert.ToDateTime(source);
}
return null;
}
public static int? ToNullableInt(this string source)
{
var i = 0;
return int.TryParse(source, out i) ? (int?)i : null;
}
public static string ToPlural(this string singular)
{
// Multiple words in the form A of B : Apply the plural to the first word only (A)
int index = singular.LastIndexOf(" of ");
if (index > 0) return (singular.Substring(0, index)) + singular.Remove(0, index).ToPlural();
// single Word rules
//sibilant ending rule
if (singular.EndsWith("sh")) return singular + "es";
if (singular.EndsWith("ch")) return singular + "es";
if (singular.EndsWith("us")) return singular + "es";
if (singular.EndsWith("ss")) return singular + "es";
//-ies rule
if (singular.EndsWith("y")) return singular.Remove(singular.Length - 1, 1) + "ies";
// -oes rule
if (singular.EndsWith("o")) return singular.Remove(singular.Length - 1, 1) + "oes";
// -s suffix rule
return singular + "s";
}
public static bool IsValidEmailAddress(this string s)
{
Regex regex = new Regex(@"^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$");
return regex.IsMatch(s);
}
///
/// Converts a string into a "SecureString"
///
/// Input String
///
public static System.Security.SecureString ToSecureString(this String str)
{
System.Security.SecureString secureString = new System.Security.SecureString();
foreach (Char c in str)
secureString.AppendChar(c);
return secureString;
}
public static string ToProperCase(this string text)
{
System.Globalization.CultureInfo cultureInfo = System.Threading.Thread.CurrentThread.CurrentCulture;
System.Globalization.TextInfo textInfo = cultureInfo.TextInfo;
return textInfo.ToTitleCase(text);
}
public static bool IsNumeric(this string theValue)
{
long retNum;
return long.TryParse(theValue, System.Globalization.NumberStyles.Integer, System.Globalization.NumberFormatInfo.InvariantInfo, out retNum);
}
public static bool IsNotNullOrEmpty(this string input)
{
return !String.IsNullOrEmpty(input);
}
public static bool IsNullOrEmpty(this string input)
{
return String.IsNullOrEmpty(input);
}
public static bool IsNotNullOrEmptyOrSpace(this string input)
{
if (!String.IsNullOrEmpty(input))
{
return !String.IsNullOrEmpty(input.Trim());
}
else
{
return true;
}
}
public static bool IsNullOrEmptyOrSpace(this string input)
{
if (!String.IsNullOrEmpty(input))
{
return String.IsNullOrEmpty(input.Trim());
}
else
{
return true;
}
}
///
/// Count all words in a given string
///
/// string to begin with
/// int
public static int WordCount(this string input)
{
var count = 0;
try
{
// Exclude whitespaces, Tabs and line breaks
var re = new Regex(@"[^\s]+");
var matches = re.Matches(input);
count = matches.Count;
}
catch
{
}
return count;
}
}
Compiled By: Rajesh Rolen
