Pastable version of StringExt.cs (String Extension)

<pre class='prettyprint' language='cs'>namespace Utilities
{
    using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Text.RegularExpressions;

public static class StringExt
    {

public static bool IsEmail(this string inputstr)
        {
            // exit if the string is null or empty
            if (inputstr.IsEmpty())
                return false;

string strRegex = @&quot;^([a-zA-Z0-9_\-\.\+]+)@((\[[0-9]{1,3}&quot; +
                  @&quot;\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9\-]+\&quot; +
                  @&quot;.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$&quot;;

return inputstr.MatchRegex(strRegex);
        }

public static bool IsZip(this string inputstr)
        {
            // exit if the string is null or empty
            if (inputstr.IsEmpty())
                return false;

string strRegex = @&quot;^\d{5}$|^\d{5}-\d{4}$&quot;;

return inputstr.MatchRegex(strRegex);
        }

public static bool IsStateAbbrv(this string inputstr)
        {
            return inputstr.IsStateAbbrv(false);
        }

public static bool IsStateAbbrv(this string inputstr, bool CaseSensitive)
        {
            // exit if the string is null or empty
            if (inputstr.IsEmpty())
                return false;

string strRegex = @&quot;^((AL)|(AK)|(AS)|(AZ)|(AR)|(CA)|(CO)|(CT)|(DE)|(DC)|(FM)|(FL)|&quot; +
                @&quot;(GA)|(GU)|(HI)|(ID)|(IL)|(IN)|(IA)|(KS)|(KY)|(LA)|(ME)|(MH)|(MD)|(MA)|(MI)|&quot; +
                @&quot;(MN)|(MS)|(MO)|(MT)|(NE)|(NV)|(NH)|(NJ)|(NM)|(NY)|(NC)|(ND)|(MP)|(OH)|(OK)|&quot; +
                @&quot;(OR)|(PW)|(PA)|(PR)|(RI)|(SC)|(SD)|(TN)|(TX)|(UT)|(VT)|(VI)|(VA)|(WA)|(WV)|&quot; +
                @&quot;(WI)|(WY))$&quot;;

return inputstr.MatchRegex(strRegex, CaseSensitive);
        }

public static bool IsStateName(this string inputstr)
        {
            return inputstr.IsStateName(false);
        }

public static bool IsStateName(this string inputstr, bool CaseSensitive)
        {
            // exit if the string is null or empty
            if (inputstr.IsEmpty())
                return false;

return inputstr.MatchRegex(strRegex, CaseSensitive);
        }

public static bool IsEmpty(this string inputstr)
        {
            if (inputstr == null || inputstr.Trim().Length == 0)
            {
                return true;
            }
            return false;
        }

public static bool IsPhone(this string inputstr)
        {
            // exit if the string is null or empty
            if (inputstr.IsEmpty())
                return false;

string strRegex = @&quot;^\D?(\d{3})\D?\D?(\d{3})\D?(\d{4})$&quot;;
            return inputstr.MatchRegex(strRegex);
        }

public static bool MatchRegex(this string inputstr, string regex)
        {
            return inputstr.MatchRegex(regex, false);
        }

public static bool MatchRegex(this string inputstr, string regex, bool CaseSensitive)
        {
            var IsCaseSensitive = RegexOptions.IgnoreCase;
            if (CaseSensitive)
            {
                IsCaseSensitive = RegexOptions.None;
            }

return System.Text.RegularExpressions.Regex.IsMatch(inputstr, regex, IsCaseSensitive);
        }

public static bool EqualsIgnoreCase(this string s, string value)
        {
            return s.ToLowerInvariant() == value.ToLowerInvariant();
        }
        
        // be nice to VB &amp; CF devlopers
        public static string Left(this string s, int position)
        {
            return s.Substring(0, position);
        }

// be nice to VB &amp; CF devlopers
        public static string Right(this string s, int position)
        {
            return s.Substring(s.Length - position);
        }

public static string Reverse(this string s)
        {
            char[] charArray = s.ToCharArray();
            Array.Reverse(charArray);
            return new string(charArray);
        }

public static string FormatTitleCase(this string s)
        {
            string[] words = s.Split(' ');

string result = string.Empty;
            string temp = string.Empty;

foreach (string i in words)
            {
                temp = i.ToLower();
                result = result + i.Substring(0, 1).ToUpper() + i.Substring(1) + &quot; &quot;;
            }

result = result.Substring(0, result.Length - 1);

return result;
        }

/// &lt;summary&gt;
        /// convert a string that is CSV formated into a List
        /// credit goes to www.usualdosage.com where I got most of this code
        /// &lt;/summary&gt;
        /// &lt;param name=&quot;s&quot;&gt;&lt;/param&gt;
        /// &lt;returns&gt;List&lt;/returns&gt;
        public static List&lt;string&gt; CSVToList(this string s)
        {
            char CHAR_COMMA = Convert.ToChar(44);
            char CHAR_QUOTE = Convert.ToChar(34);
            char CHAR_PIPE = Convert.ToChar(124);
            char CHAR_BACKQUOTE = Convert.ToChar(96);
            // Create a new array to contain the return values
       
            string strCurrent = s;
            string[] arrTokens = null;
            
            // Replace any instance of double quotes with a back quote
            strCurrent = strCurrent.Replace(&quot;\&quot;\&quot;&quot;, &quot;`&quot;);
            
            if (!strCurrent.Contains(CHAR_QUOTE.ToString())) // No quotes, so just split on commas
            {
                arrTokens = strCurrent.Split(CHAR_COMMA);
            }
            else // Contains quotes, so more detailed parsing needed
            {
                bool bQuote = false;
                bool bEscape = false;
            
                // Convert temp to a char array to make it easier to check each char
                char[] arrTempChars = strCurrent.ToCharArray();
                for (int i = 0; i &lt; arrTempChars.Length; i++)
                {
                    // Loop through until we find a quote. If found, flip the bool value
                    if (arrTempChars[i] == CHAR_QUOTE)
                    {
                        if (!bEscape)
                        bQuote = !bQuote;
                    }

// If weâ€™re in a quote group and find a comma, change it to a temp char for the moment
                    if (bQuote &amp;&amp; (arrTempChars[i] == CHAR_COMMA))
                    {
                        arrTempChars[i] = CHAR_PIPE;
                    }
                }
               // Parse out the modified character array into a string
               string strReassemble = string.Empty;
               
               for (int j = 0; j &lt; arrTempChars.Length; j++)
               {
                   strReassemble = strReassemble + arrTempChars[j].ToString();
               }
               
               // Remove the quotes, which will leave just commas, and split
               strReassemble = strReassemble.Replace(CHAR_QUOTE.ToString(), string.Empty);
               arrTokens = strReassemble.Split(CHAR_COMMA);
               
               // Loop through the array, and reset the temp chars back to
               // commas, and replace the back quotes with double quotes
               for (int k = 0; k &lt; arrTokens.Length; k++)
               {
                   arrTokens[k] = arrTokens[k].Replace(CHAR_PIPE, CHAR_COMMA);
                   arrTokens[k] = arrTokens[k].Replace(CHAR_BACKQUOTE, CHAR_QUOTE);
               }
            }

List&lt;string&gt; rtrnList = new List&lt;string&gt;();
            foreach (string entry in arrTokens)
            {
                rtrnList.Add(entry);
            }

return rtrnList;
        }

/// &lt;summary&gt;
        /// Convert a string[] into a single string that is seperated by a 
        /// delimiter
        /// &lt;/summary&gt;
        /// &lt;param name=&quot;s&quot;&gt;&lt;/param&gt;
        /// &lt;returns&gt;&lt;/returns&gt;
        public static string ToDelimitedString(this string[] s)
        {
            return s.ToDelimitedString(&quot;,&quot;, false);
        }

public static string ToDelimitedString(this string[] s, string vDelimeter)
        {
            return s.ToDelimitedString(vDelimeter, false);
        }
        public static string ToDelimitedString(this string[] s, bool QuoteEachEntry)
        {
            return s.ToDelimitedString(&quot;,&quot;, QuoteEachEntry);
        }

public static string ToDelimitedString(this string[] s, string Delimeter, bool QuoteEachEntry)
        {
            string result = string.Empty;
            string vDelim = string.Empty;

foreach (string element in s)
            {
                if(QuoteEachEntry)
                    result += vDelim + &quot;\&quot;&quot; + element + &quot;\&quot;&quot;;
                else
                    result += vDelim + element;
                vDelim = Delimeter;
            }
            return result;
        }
    }
}</pre>
<a href="http://www.refactormycode.com/codes/422-stringext-cs-string-extension" style="color:#fff" title="As seen on RefactorMyCode.com"><img alt="Small_logo" src="http://www.refactormycode.com/images/small_logo.gif" style="border:0" /></a>

Refactor :my => 'code'

Recent

Popular

Pastable version of StringExt.cs (String Extension)