These are extension methods for
"System.String" class
. Some are written by me and the rest are collected from other sources. Hope you find them useful :)
using System;
using System.IO;
using System.Linq;
using System.Net.Mail;
using System.Text.RegularExpressions;
using System.Xml;
using System.Xml.Serialization;
namespace DevelopmentSimplyPut.ExtensionMethods.StringEM
{
public static class StringExtensionMethods
{
/// <summary>
/// Repeats a string for a given number of times
/// </summary>
/// <param name="source">String</param>
/// <param name="numberOfTimes">Number of times</param>
/// <returns></returns>
public static string ext_RepeatNoOfTimes(this string source, int numberOfTimes)
{
string result = string.Empty;
for (int i = 0; i < numberOfTimes; i++)
{
result += source;
}
return result;
}
/// <summary>
/// Formats numbers inside a string into a given number of digits with extra preceeding zeros
/// </summary>
/// <param name="source">String</param>
/// <param name="numOfDigits">Number of digits</param>
/// <returns></returns>
public static string ext_PutNumbersIntoNoOfDigits(this string source, int numOfDigits)
{
string result = source;
result = Regex.Replace(result, @"\d+", new MatchEvaluator(delegate(Match match)
{
if (match.Length < numOfDigits)
{
string zero = "0";
result = zero.ext_RepeatNoOfTimes(numOfDigits - match.Length) + match.Value;
return result;
}
else
{
result = match.Value;
return result;
}
}));
return result;
}
/// <summary>
/// Gets the {n} first characters of a string
/// </summary>
/// <param name="source">String</param>
/// <param name="NumOfChars">Number of characters</param>
/// <returns></returns>
public static string ext_First(this string source, int NumOfChars)
{
if (string.IsNullOrEmpty(source) || source.Length <= NumOfChars)
{
return source;
}
return source.Substring(0, NumOfChars);
}
/// <summary>
/// Gets the {n} last characters of a string
/// </summary>
/// <param name="source">String</param>
/// <param name="NumOfChars">Number of characters</param>
/// <returns></returns>
public static string ext_Last(this string source, int NumOfChars)
{
if (string.IsNullOrEmpty(source) || source.Length <= NumOfChars)
{
return source;
}
return source.Substring(source.Length - NumOfChars, NumOfChars);
}
/// <summary>
/// Splits a string into two parts, the first one is the string part before the last existance of a certain character,
/// the second one is the string part after the last existance of the same character
/// </summary>
/// <param name="source"></param>
/// <param name="splitAtChar"></param>
/// <returns></returns>
public static string[] ext_SplitAtLastCharExistance(this string source, char splitAtChar)
{
string[] result = { string.Empty, string.Empty };
if (string.IsNullOrEmpty(source))
{
//string is empty
return result;
}
if (!(source.Contains(splitAtChar)))
{
//character doesn't exist in the string
result[0] = source;
return result;
}
if (source.Length == 1)
{
//the string is only the character itself
return result;
}
int temp = source.LastIndexOf(splitAtChar);
if (temp == 0)
{
//the character is at the start
result[0] = string.Empty;
result[1] = source.Substring(temp + 1, source.Length - temp - 1);
}
else if (temp == source.Length - 1)
{
//the character is at the end
result[0] = source.Substring(0, temp);
result[1] = string.Empty;
}
else
{
//the character is in the middle
result[0] = source.Substring(0, temp);
result[1] = source.Substring(temp + 1, source.Length - temp - 1);
}
return result;
}
/// <summary>
/// Gets the preceding part of a string except the last given number of characters
/// </summary>
/// <param name="source">String</param>
/// <param name="NumOfChars">Number of characters</param>
/// <returns></returns>
public static string ext_ExceptLastNoOfChars(this string source, int NumOfChars)
{
if (string.IsNullOrEmpty(source) || source.Length <= NumOfChars)
{
return string.Empty;
}
return source.Substring(0, source.Length - NumOfChars);
}
/// <summary>
/// Gets the succeeding part of a string except the first given number of characters
/// </summary>
/// <param name="source"></param>
/// <param name="NumOfChars"></param>
/// <returns></returns>
public static string ext_ExceptFirstNoOfChars(this string source, int NumOfChars)
{
if (string.IsNullOrEmpty(source) || source.Length <= NumOfChars)
{
return string.Empty;
}
return source.Substring(NumOfChars, source.Length - NumOfChars);
}
/// <summary>
/// Formats a string with one literal placeholder.
/// </summary>
/// <param name="text">The extension text</param>
/// <param name="arg0">Argument 0</param>
/// <returns>The formatted string</returns>
public static string ext_FormatWith(this string text, object arg0)
{
return string.Format(text, arg0);
}
/// <summary>
/// Formats a string with two literal placeholders.
/// </summary>
/// <param name="text">The extension text</param>
/// <param name="arg0">Argument 0</param>
/// <param name="arg1">Argument 1</param>
/// <returns>The formatted string</returns>
public static string ext_FormatWith(this string text, object arg0, object arg1)
{
return string.Format(text, arg0, arg1);
}
/// <summary>
/// Formats a string with tree literal placeholders.
/// </summary>
/// <param name="text">The extension text</param>
/// <param name="arg0">Argument 0</param>
/// <param name="arg1">Argument 1</param>
/// <param name="arg2">Argument 2</param>
/// <returns>The formatted string</returns>
public static string ext_FormatWith(this string text, object arg0, object arg1, object arg2)
{
return string.Format(text, arg0, arg1, arg2);
}
/// <summary>
/// Formats a string with a list of literal placeholders.
/// </summary>
/// <param name="text">The extension text</param>
/// <param name="args">The argument list</param>
/// <returns>The formatted string</returns>
public static string ext_FormatWith(this string text, params object[] args)
{
return string.Format(text, args);
}
/// <summary>
/// Formats a string with a list of literal placeholders.
/// </summary>
/// <param name="text">The extension text</param>
/// <param name="provider">The format provider</param>
/// <param name="args">The argument list</param>
/// <returns>The formatted string</returns>
public static string ext_FormatWith(this string text, IFormatProvider provider, params object[] args)
{
return string.Format(provider, text, args);
}
/// <summary>
/// Deserialises an xml string in to an object of Type T
/// </summary>
/// <typeparam name="T">Any class type</typeparam>
/// <param name="xml">Xml as string to deserialise from</param>
/// <returns>A new object of type T is successful, null if failed</returns>
public static T ext_XmlDeserialize<T>(this string xml) where T : class
{
var serialiser = new XmlSerializer(typeof(T));
T newObject;
using (var stringReader = new StringReader(xml))
{
using (var xmlReader = new XmlTextReader(stringReader))
{
try
{
newObject = serialiser.Deserialize(xmlReader) as T;
}
catch (InvalidOperationException) // String passed is not Xml, return null
{
return null;
}
}
}
return newObject;
}
/// <summary>
/// Parses a string into an Enum
/// </summary>
/// <typeparam name="T">The type of the Enum</typeparam>
/// <param name="value">String value to parse</param>
/// <returns>The Enum corresponding to the stringExtensions</returns>
public static T ext_ToEnum<T>(this string value)
{
return ext_ToEnum<T>(value, false);
}
/// <summary>
/// Parses a string into an Enum
/// </summary>
/// <typeparam name="T">The type of the Enum</typeparam>
/// <param name="value">String value to parse</param>
/// <param name="ignorecase">Ignore the case of the string being parsed</param>
/// <returns>The Enum corresponding to the stringExtensions</returns>
public static T ext_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);
}
/// <summary>
/// Toes the integer.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="defaultvalue">The defaultvalue.</param>
/// <returns></returns>
public static int ext_ToInteger(this string value, int defaultvalue)
{
return (int)ext_ToDouble(value, defaultvalue);
}
/// <summary>
/// Toes the integer.
/// </summary>
/// <param name="value">The value.</param>
/// <returns></returns>
public static int ext_ToInteger(this string value)
{
return ext_ToInteger(value, 0);
}
/// <summary>
/// Toes the double.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="defaultvalue">The defaultvalue.</param>
/// <returns></returns>
public static double ext_ToDouble(this string value, double defaultvalue)
{
double result;
if (double.TryParse(value, out result))
{
return result;
}
else return defaultvalue;
}
/// <summary>
/// Toes the double.
/// </summary>
/// <param name="value">The value.</param>
/// <returns></returns>
public static double ext_ToDouble(this string value)
{
return ext_ToDouble(value, 0);
}
/// <summary>
/// Toes the date time.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="defaultvalue">The defaultvalue.</param>
/// <returns></returns>
public static DateTime? ext_ToDateTime(this string value, DateTime? defaultvalue)
{
DateTime result;
if (DateTime.TryParse(value, out result))
{
return result;
}
else return defaultvalue;
}
/// <summary>
/// Toes the date time.
/// </summary>
/// <param name="value">The value.</param>
/// <returns></returns>
public static DateTime? ext_ToDateTime(this string value)
{
return ext_ToDateTime(value, null);
}
/// <summary>
/// Converts a string value to bool value, supports "T" and "F" conversions.
/// </summary>
/// <param name="value">The string value.</param>
/// <returns>A bool based on the string value</returns>
public static bool? ext_ToBoolean(this string value)
{
if (string.Compare("T", value, true) == 0)
{
return true;
}
if (string.Compare("F", value, true) == 0)
{
return false;
}
bool result;
if (bool.TryParse(value, out result))
{
return result;
}
else return null;
}
/// <summary>
/// Gets the string value or a default value
/// </summary>
/// <param name="value">String</param>
/// <returns></returns>
public static string ext_GetValueOrEmpty(this string value)
{
return ext_GetValueOrDefault(value, string.Empty);
}
/// <summary>
/// Gets the string value or a default value
/// </summary>
/// <param name="value">String</param>
/// <param name="defaultvalue">Default value</param>
/// <returns></returns>
public static string ext_GetValueOrDefault(this string value, string defaultvalue)
{
if (value != null) return value;
return defaultvalue;
}
/// <summary>
/// Converts string to a Name-Format where each first letter is Uppercase.
/// </summary>
/// <param name="value">The string value.</param>
/// <returns></returns>
public static string ext_ToUpperLowerNameVariant(this string value)
{
if (string.IsNullOrEmpty(value)) return "";
char[] valuearray = value.ToLower().ToCharArray();
bool nextupper = true;
for (int i = 0; i < (valuearray.Count() - 1); i++)
{
if (nextupper)
{
valuearray[i] = char.Parse(valuearray[i].ToString().ToUpper());
nextupper = false;
}
else
{
switch (valuearray[i])
{
case ' ':
case '-':
case '.':
case ':':
case '\n':
nextupper = true;
break;
default:
nextupper = false;
break;
}
}
}
return new string(valuearray);
}
/// <summary>
/// Encryptes a string using the supplied key. Encoding is done using RSA encryption.
/// </summary>
/// <param name="stringToEncrypt">String that must be encrypted.</param>
/// <param name="key">Encryptionkey.</param>
/// <returns>A string representing a byte array separated by a minus sign.</returns>
/// <exception cref="ArgumentException">Occurs when stringToEncrypt or key is null or empty.</exception>
public static string ext_Encrypt(this string stringToEncrypt, string key)
{
if (string.IsNullOrEmpty(stringToEncrypt))
{
throw new ArgumentException("An empty string value cannot be encrypted.");
}
if (string.IsNullOrEmpty(key))
{
throw new ArgumentException("Cannot encrypt using an empty key. Please supply an encryption key.");
}
System.Security.Cryptography.CspParameters cspp = new System.Security.Cryptography.CspParameters();
cspp.KeyContainerName = key;
System.Security.Cryptography.RSACryptoServiceProvider rsa = new System.Security.Cryptography.RSACryptoServiceProvider(cspp);
rsa.PersistKeyInCsp = true;
byte[] bytes = rsa.Encrypt(System.Text.UTF8Encoding.UTF8.GetBytes(stringToEncrypt), true);
return BitConverter.ToString(bytes);
}
/// <summary>
/// Decryptes a string using the supplied key. Decoding is done using RSA encryption.
/// </summary>
/// <param name="key">Decryptionkey.</param>
/// <returns>The decrypted string or null if decryption failed.</returns>
/// <exception cref="ArgumentException">Occurs when stringToDecrypt or key is null or empty.</exception>
public static string ext_Decrypt(this string stringToDecrypt, string key)
{
string result = null;
if (string.IsNullOrEmpty(stringToDecrypt))
{
throw new ArgumentException("An empty string value cannot be encrypted.");
}
if (string.IsNullOrEmpty(key))
{
throw new ArgumentException("Cannot decrypt using an empty key. Please supply a decryption key.");
}
try
{
System.Security.Cryptography.CspParameters cspp = new System.Security.Cryptography.CspParameters();
cspp.KeyContainerName = key;
System.Security.Cryptography.RSACryptoServiceProvider rsa = new System.Security.Cryptography.RSACryptoServiceProvider(cspp);
rsa.PersistKeyInCsp = true;
string[] decryptArray = stringToDecrypt.Split(new string[] { "-" }, StringSplitOptions.None);
byte[] decryptByteArray = Array.ConvertAll<string, byte>(decryptArray, (s => Convert.ToByte(byte.Parse(s, System.Globalization.NumberStyles.HexNumber))));
byte[] bytes = rsa.Decrypt(decryptByteArray, true);
result = System.Text.UTF8Encoding.UTF8.GetString(bytes);
}
finally
{
// no need for further processing
}
return result;
}
/// <summary>
/// Determines whether it is a valid URL.
/// </summary>
/// <returns>
/// <c>true</c> if [is valid URL] [the specified text]; otherwise, <c>false</c>.
/// </returns>
public static bool ext_IsValidUrl(this string text)
{
System.Text.RegularExpressions.Regex rx = new System.Text.RegularExpressions.Regex(@"http(s)?://([\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?");
return rx.IsMatch(text);
}
/// <summary>
/// Determines whether it is a valid email address
/// </summary>
/// <returns>
/// <c>true</c> if [is valid email address] [the specified s]; otherwise, <c>false</c>.
/// </returns>
public static bool ext_IsValidEmailAddress(this string email)
{
System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(@"^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$");
return regex.IsMatch(email);
}
/// <summary>
/// Send an email using the supplied string.
/// </summary>
/// <param name="body">String that will be used i the body of the email.</param>
/// <param name="subject">Subject of the email.</param>
/// <param name="sender">The email address from which the message was sent.</param>
/// <param name="recipient">The receiver of the email.</param>
/// <param name="server">The server from which the email will be sent.</param>
/// <returns>A boolean value indicating the success of the email send.</returns>
public static bool ext_Email(this string body, string subject, string sender, string recipient, string server)
{
try
{
// To
MailMessage mailMsg = new MailMessage();
mailMsg.To.Add(recipient);
// From
MailAddress mailAddress = new MailAddress(sender);
mailMsg.From = mailAddress;
// Subject and Body
mailMsg.Subject = subject;
mailMsg.Body = body;
// Init SmtpClient and send
SmtpClient smtpClient = new SmtpClient(server);
System.Net.NetworkCredential credentials = new System.Net.NetworkCredential();
smtpClient.Credentials = credentials;
smtpClient.Send(mailMsg);
}
catch (Exception ex)
{
throw new Exception("Could not send mail from: " + sender + " to: " + recipient + " thru smtp server: " + server + "\n\n" + ex.Message, ex);
}
return true;
}
/// <summary>
/// Truncates the string to a specified length and replace the truncated to a ...
/// </summary>
/// <param name="maxLength">total length of characters to maintain before the truncate happens</param>
/// <returns>truncated string</returns>
public static string ext_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;
}
/// <summary>
/// Converts to a HTML-encoded string
/// </summary>
/// <param name="data">The data.</param>
/// <returns></returns>
public static string ext_HtmlEncode(this string data)
{
return System.Web.HttpUtility.HtmlEncode(data);
}
/// <summary>
/// Converts the HTML-encoded string into a decoded string
/// </summary>
public static string ext_HtmlDecode(this string data)
{
return System.Web.HttpUtility.HtmlDecode(data);
}
/// <summary>
/// Parses a query string into a System.Collections.Specialized.NameValueCollection
/// using System.Text.Encoding.UTF8 encoding.
/// </summary>
public static System.Collections.Specialized.NameValueCollection ext_ParseQueryString(this string query)
{
return System.Web.HttpUtility.ParseQueryString(query);
}
/// <summary>
/// Encode an Url string
/// </summary>
public static string ext_UrlEncode(this string url)
{
return System.Web.HttpUtility.UrlEncode(url);
}
/// <summary>
/// Converts a string that has been encoded for transmission in a URL into a
/// decoded string.
/// </summary>
public static string ext_UrlDecode(this string url)
{
return System.Web.HttpUtility.UrlDecode(url);
}
/// <summary>
/// Encodes the path portion of a URL string for reliable HTTP transmission from
/// the Web server to a client.
/// </summary>
public static string ext_UrlPathEncode(this string url)
{
return System.Web.HttpUtility.UrlPathEncode(url);
}
/// <summary>
/// Replaces the format item in a specified System.String with the text equivalent
/// of the value of a specified System.Object instance.
/// </summary>
/// <param name="arg">The arg.</param>
/// <param name="additionalArgs">The additional args.</param>
public static string ext_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());
}
}
/// <summary>
/// Determines whether [is not null or empty] [the specified input].
/// </summary>
/// <returns>
/// <c>true</c> if [is not null or empty] [the specified input]; otherwise, <c>false</c>.
/// </returns>
public static bool ext_IsNotNullOrEmpty(this string input)
{
return !String.IsNullOrEmpty(input);
}
}
}
