C# String Library

by Chad Finsterwald

This code sample applies to ASP.NET for the .NET 2.0 framework. Examples are written in C#.

Overview
Methods
Examples
Conclusion

Overview:

Recently I was doing some coding and switching back and forth between a project written in PHP and another in C#. Having rebuilt my PHP muscle memory after a couple months of neglect, I instinctively called nl2br on a string in C#. Obviously instead of the desired result, I got a compliation error. Like a tiny bolt of lightning, it struck me that there are a number of useful functions in the PHP string library that are missing in C#'s implentation of String. This library is the result of that wee epiphany.

The intent of the article is to introduce you to the PHP inspired String Library for .Net. I did not port over all the PHP String functions --as some of the methods in PHP's library are a little too exotic for my taste --such as the levenshtein function. or the even more questionable str_rot13. I am just not sure when I'd need those, so I left them out. (In fact, if anyone has any examples of when they used str_rot13, please let me know!) I also added a few methods that are not in PHP's library but that I thought would be helpful --e.g. TrimIntraWords, FilterWords, etc.

Methods

Below is a list of the method names and descriptions in the string library. I did not give the signatures, but many of these have several overloads. Also, I did not keep the PHP method names as those names do not conform to .Net best practices. You can view all the methods, their overloads, and documentation by clicking on the "View the Code" button below or by just downloading the .cs file.

Base64StringEncode: Base64 encodes a string.
Base64StringDecode: Decodes a Base64 string.
CaseInsenstiveReplace: A case insenstive replace function.
ReplaceFirst: Replaces the first occurence of a string with the replacement value. The Replace is case senstive. [The inclusion of this method and ReplaceLast was suggested by a reader's comment.]
ReplaceLast: Replaces the last occurence of a string with the replacement value. The replace is case senstive.
FilterWords: Removes all the words passed in the filter words parameters. The replace is NOT case sensitive.
HasWords: Checks the passed string to see if it contains any of the passed words. Not case-sensitive.
HtmlSpecialEntitiesEncode: A wrapper around HttpUtility.HtmlEncode.
HtmlSpecialEntitiesDecode: A wrapper around HttpUtility.HtmlDecode.
MD5String: MD5 encodes the passed string.
MD5VerifyString: Verifies a string against the passed MD5 hash.
PadLeftHtmlSpaces: Left pads the passed string using the HTML non-breaking space ( ) for the total number of spaces.
CaseInsenstiveReplace: Performs a case insenstive replace.
PadLeft: Left pads the passed string 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.)
PadRightHtmlSpaces: Right pads the passed string using the HTML non-breaking space ( ) for the total number of spaces.
PadRight: Right pads the passed string 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.)
RemoveNewLines: Removes the new line (\n) and carriage return (\r) symbols.
Reverse: Reverses the passed string.
SentenceCase: Converts a string to sentence case.
SpaceToNbsp: Converts all spaces to HTML non-breaking spaces.
StripTags: Removes all HTML tags from the passed string.
TitleCase: Converts a string to title case.
TrimIntraWords: Removes multiple spaces between words.
NewLineToBreak: Converts each new line (\n) and carriage return (\r) symbols to the HTML <br /> tag.
WordWrap: Wraps the passed string at the passed total number of characters (if cuttOff is true)or at the next whitespace (if cutOff is false). Uses the environment new linesymbol for the break text.

Click to View the Code

C# String Library:

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 (&nbsp;)
      /// 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 = "&nbsp;";
         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 (&nbsp;)
      /// 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 = "&nbsp;";
         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 = "&nbsp;";
         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(); 
      }
   }
}

Examples

Below are some examples of the methods. As most are fairly self-explanatory, I've only included a few.

Reverse: 'CoreWeb' to 'beWeroC'
TitleCase: 'this is a test' to 'This is a Test'
SentenceCase: 'this is a test' to 'This is a test'
PadLeftHtmlSpaces: 'CoreWeb' to 'CoreWeb'
MD5String: 'Finsterwald' to 'c7ea6dc934da143bcf00d14f722d74ea'
CaseInsenstiveReplace: 'This is a Test' to 'This is a Result'

I think you get the idea...

Conclusion

I hope that you found this helpful. I look foward to your comments and if you extend the library, please send me what you've done.

Subject	Name	Date Submitted
Change page: 1 2 \| Displaying page 1 of 2, items 1 to 20 of 35.
C# String Library - Excellent Article Excellent Article-Its very useful for me. Regards, Rajarajan Reply View Thread	rajarajan	9/2/2006 3:30:09 PM
C# String Library - Excellent Article Excellent Article-Its very useful for me. Regards, Rajarajan Reply View Thread	rajarajan	9/2/2006 3:30:33 PM
C# String Library Thanks, this is exactly what I needed. Reply View Thread	Kalel	9/12/2006 8:26:54 AM
Good Article Good collection of library http://www.vikramlakhotia.com/ Reply View Thread	vikram	9/19/2006 1:33:46 AM
What about ReplaceFirst ? Hi. The string method Replace replace ALL the occurances of the given string(char) with the specified one. In many situations I whan to replace only the first match. Is it possible to extend your lib with this function. It's very easy to implement : public static string ReplaceFirst(string input, string oldValue, string newValue) { int index = input.IndexOf(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(); } } Even without this method it is a good string library. Reply View Thread	Peter	9/19/2006 2:53:57 AM
re: What about ReplaceFirst ? Hi Peter, Thanks for the suggestion. I will check out your code and add the method this evening. Much appreciated. Reply View Thread	Chad Finsterwald	9/19/2006 12:54:37 PM
re: What about ReplaceFirst ? Peter, I've included the method you suggested and a ReplaceLast as well. It turns out the RegEx Replace method can take an int which is the maximum number of instances to replace for a string, so I used that for ReplaceFirst. I did use your code for ReplaceLast as the Regex Replace function would not work as well there. In either case, many thanks for the suggestion. Reply View Thread	Chad Finsterwald	9/19/2006 8:19:50 PM
A helpful contribution Hi Chad, I must say that it is a helpful contribution for .NET developer commuity. I can see that CoreWeb team is submitting quite useful articles. Please extend my word of appreciation to the whole team. Regards Ahmad UK Reply View Thread	Ahmad	9/19/2006 5:38:54 AM
re: A helpful contribution Your comment was incredibly nice! Thanks for taking the time to submit it. Reply View Thread	Chad Finsterwald	9/19/2006 12:57:29 PM
re: A helpful contribution You are welcome, Chad! Regards Ahmad Reply View Thread	Ahmad	9/21/2006 4:55:13 AM
awesome idea I too went from php => c# and lamented the lack of certain user-friendly functions from php. In particular the flexability of arrays. When I started .NET (which was pre-2.0 and hense pre-generics) it was a bigger deal. My 2nd biggest gripe was the lack of string stuff like this. Great contibution! Reply View Thread	dinah	9/19/2006 2:57:16 PM
re: awesome idea guys,I forgot the big one: phalanger at http://www.php-compiler.net/ also read the license here:http://www.codeplex.com/Project/License.aspx?ProjectName=Phalanger Enjoy, Joe Reply View Thread	Joe	9/26/2006 7:16:42 AM
suggestion In things like TitleCase where foreach and if need to be nested, I'd recommend doing the if 1st and the foreach inside of the if and the else rather than vice versa. If you do the foreach loop, you are doing many, many if checks where only 1 is needed the other way Reply View Thread	dinah	9/20/2006 8:51:24 AM
re: suggestion Thanks for the suggestion. I am not sure, however, that it is applicable in this case as I need to check each string token if it is a short word and if it is, ignore it. So as I see it the check needs to be repeated so the if...else condition must be contained within the the for...each that iterates through each token. Or did I misunderstand your suggestion. Thanks. Reply View Thread	Chad Finsterwald	9/20/2006 10:20:47 AM
very helpful, but.. this is very useful. .Net already has the capability for converting strings to title case. is there a reason you didn't use this? Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(string) Reply View Thread	db	9/20/2006 11:31:55 AM
re: very helpful, but.. There is an excellent reason I did not use the method you suggested: namely, I did not know about it!!! So thanks for letting me know. I will check it out and make sure it does all things things I would want it to. And you have to admit, it is a really wierd place for a TitleCase method... Reply View Thread	Chad Finsterwald	9/20/2006 11:40:35 AM
re: very helpful, but.. update Just checked out the TextInfo class and TitleCase Method. I think it is a good replacement for what I wrote with one small caveat. Namely, in the example from MSDN it will covert "wAr aNd pEaCe" to "War And Peace". My method, by expanding on the ignore words functionality, could be made to return the more correct "War and Peace." I think this makes the solution I offer a bit more flexible and so for this library I will leave it as is. Thanks and I really appreciate your turning me on to the other way of doing this. Reply View Thread	Chad Finsterwald	9/20/2006 11:54:00 AM
re: very helpful, but.. it is a weird place. it took me a long time to find it. one of the benefits however is the language/culture independence. i.e. it should work correctly for English, French, Italian, etc. Reply View Thread	db	9/20/2006 2:22:49 PM
something for the world This article begs the question, if code classes are the building blocks of development, why hasn't somebody started a library of comman classes ? there are too many sites that post example code but I've never seen one dedicated to just code classes . That would be useful. Reply View Thread	Jon	9/20/2006 12:35:08 PM
re: something for the world for php, http://www.phpclasses.org/ for .Net, gotdotnet.com has quite a few good projects in general, hotscripts.com devx.com and devshed.com My $0.02, HTH, Joe Reply View Thread	Joe	9/26/2006 7:08:39 AM


* Name:		Email Address:
Include me on future newsletters or mailings. (Your email address will not be displayed or shared.)
* Subject:
* Message:
Please enter the code shown below. If you cannot read it, press "reset image" to generate a new one.
		* Enter code:

C# String Library

by Chad Finsterwald

Contents

Overview:

Methods

Examples

Conclusion

Comments

About the Author

Chad Finsterwald

Other Articles by Chad Finsterwald: