My StringHelper class

I've posted a few code snippets and some people noticed that there are references to unresolved methods.I am using a few helper classes. This post describes my StringHelper class. 
By the way, I recently found (in the article Concatenating Strings Efficiently), that using StringBuilder is often less efficient, than simple concatenation.

Related posts:Helper functions to find pattern contaned in string from pattern List 

ProperCase function in C#  

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading;
  6.  
  7. namespace Common
  8. {
  9.         using Microsoft.VisualBasic;
  10.         using System;
  11.         using System.IO;
  12.         using System.Reflection;
  13.         using System.Text;
  14.         using System.Text.RegularExpressions;
  15.  
  16.         public static class StringHelper
  17.         {
  18.  
  19.                 // See also Westwind.Utilities.StringUtils     
  20.                 //'See also FxLib Author: Kamal Patel, Rick Hodder
  21.                 //      'Find the first entry of sToFind and returns the string after it
  22.                 //      'See also FxLib StringExtract (and StuffString)
  23.                 // Methods
  24.                 #region "String Functions"
  25.  
  26.  
  27.                 public static string LeftBefore(this string str, string sToFind)
  28.                 {
  29.                         return LeftBefore(str, sToFind, false);
  30.                 }
  31.                 //              'if sToFind not found, then the full string should be returned
  32.                 //              'if sToFind is empty, all string should be returned
  33.                 public static string LeftBefore(this string str, string sToFind, bool EmptyIfNotFound)
  34.                 {
  35.                         StringBuilder builder1 = new StringBuilder(str);
  36.                         if (sToFind.Length > 0)
  37.                         {
  38.                                 int num1 = str.IndexOf(sToFind);
  39.                                 if (num1 < 0)
  40.                                 {
  41.                                         if (EmptyIfNotFound == true) return "";
  42.                                         else return str;// 6/7/2005 full string should be returned
  43.                                 }
  44.                                 builder1.Remove(num1, builder1.Length - num1);
  45.                         }
  46.                         return builder1.ToString();
  47.                 }
  48.                 //              'if sToFind not found, then original string should be returned
  49.                 public static string LeftBeforeLast(this string str, string sToFind)
  50.                 {
  51.                         StringBuilder builder1 = new StringBuilder(str);
  52.                         if (sToFind.Length > 0)
  53.                         {
  54.                                 int num1 = str.LastIndexOf(sToFind);
  55.                                 if (num1 < 0)
  56.                                 {
  57.                                         return str;
  58.                                 }
  59.                                 builder1.Remove(num1, builder1.Length - num1);
  60.                         }
  61.                         return builder1.ToString();
  62.                 }
  63.                 public static string LeftBeforeLast(this string str, string sToFind, intFindNumberTimes)//6/1/2006
  64.                 {
  65.                         for (int i = 0; i < FindNumberTimes; i++)
  66.                         {
  67.                                 str = LeftBeforeLast(str, sToFind);
  68.                         }
  69.                         return str;
  70.                 }
  71.  
  72.                 //              'if sBefore not found, then string from the beginning should be returned
  73.                 //              'if sAfter not found, then string up to the end should be returned
  74.                 public static string MidBetween(this string str, string sBefore, string sAfter)
  75.                 {
  76.                         return MidBetween(str, sBefore, sAfter, false);
  77.                 }
  78.                 public static string MidBetween(this string str, string sBefore, string sAfter, boolEmptyIfNotFound)
  79.                 {
  80.                         string text2 = RightAfter(str, sBefore, EmptyIfNotFound);
  81.                         return LeftBefore(text2, sAfter, EmptyIfNotFound);
  82.                 }
  83.                
  84.                 /// <summary>
  85.                 ///if sToFind not found, then original string should be returned
  86.                 ///if sToFind is empty, all string should be returned
  87.                 /// </summary>
  88.                 /// <param name="str"></param>
  89.                 /// <param name="sToFind"></param>
  90.                 public static string RightAfter(this string str, string sToFind)
  91.                 {
  92.                         return RightAfter(str, sToFind, false);
  93.                 }
  94.                 /// <summary>
  95.                 ///
  96.                 /// </summary>
  97.                 /// <param name="str"></param>
  98.                 /// <param name="sToFind"></param>
  99.                 /// <param name="EmptyIfNotFound"></param>
  100.                 /// <returns></returns>
  101.                 public static string RightAfter(this string str, string sToFind, bool EmptyIfNotFound)
  102.                 {
  103.                         StringBuilder builder1 = new StringBuilder(str);
  104.                         int num1 = str.IndexOf(sToFind);
  105.                         if (num1 < 0)
  106.                         {
  107.                                 if (EmptyIfNotFound == true) return "";
  108.                                 else return str;
  109.                         }
  110.                         builder1.Remove(0, num1 + sToFind.Length);
  111.                         return builder1.ToString();
  112.                 }
  113.                 //
  114.                 /// <summary>
  115.                 ///if sToFind not found, then original string should be returned
  116.                 /// Otherwise removeBefore
  117.                 /// </summary>
  118.                 /// <param name="str"></param>
  119.                 /// <param name="sToFind"></param>
  120.                 /// <returns></returns>
  121.                 public static string RemoveBefore(this string str, string sToFind)
  122.                 {
  123.                         int num1 = str.IndexOf(sToFind);
  124.                         if (num1 > 0)
  125.                         {
  126.                                 return str.Remove(0, num1);
  127.                         }
  128.                         else
  129.                         {
  130.                                 return str;
  131.                         }
  132.                        
  133.                 }
  134.  
  135.                 //'Find the last entry of sToFind and returns the string after it
  136.                 //if sToFind not found, then original string should be returned ' 6/7/2005 change
  137.                 //if sToFind is empty, the original string should be returned
  138.                 public static string RightAfterLast(string str, string sToFind)
  139.                 {
  140.                         StringBuilder builder1 = new StringBuilder(str);
  141.                         int num1 = str.LastIndexOf(sToFind);
  142.                         if (num1 < 0)
  143.                         {
  144.                                 return str;
  145.                         }
  146.                         builder1.Remove(0, num1 + sToFind.Length);
  147.                         return builder1.ToString();
  148.                 }
  149.                 public static string RightAfterLast(string str, char chToFind, intnOccurencesNumber)//6/1/2006
  150.                 { //C++ solutions to find n'th occurence see http://www.codecomments.com/forum272/message731385.html
  151.                         string[] aStr = str.Split(chToFind);
  152.                         StringBuilder sb = new StringBuilder();
  153.                         int nPosInSplit = aStr.Length - nOccurencesNumber;
  154.                         for (int i = nPosInSplit; i < aStr.Length; i++)
  155.                         {
  156.                                 sb.Append(aStr[i]);
  157.                                 sb.Append(chToFind);
  158.                         }
  159.                         sb.Remove(sb.Length - 1, 1);//1 for char
  160.                         return sb.ToString();
  161.                 }
  162.                 //'Removes the start part of the string, if it is matchs, otherwise leave string unchanged
  163.                 public static string TrimStart(this string str, string sStartValue)
  164.                 {
  165.                         if (!String.IsNullOrWhiteSpace(str) && str.StartsWith(sStartValue))
  166.                         {
  167.                                 str = str.Remove(0, sStartValue.Length);
  168.                         }
  169.                         return str;
  170.                 }
  171.                 //              'Removes the end part of the string, if it is matchs, otherwise leave string unchanged
  172.                 public static string TrimEnd(this string str, string sEndValue)
  173.                 {
  174.                         if (str == null) { throw new NullReferenceException("str is null"); }
  175.                         if (str.EndsWith(sEndValue))
  176.                         {
  177.                                 str = str.Remove(str.Length - sEndValue.Length, sEndValue.Length);
  178.                         }
  179.                         return str;
  180.                 }
  181.                 /// <summary>
  182.                 /// If lenght of the string is greater than max allowed, remove the end
  183.                 /// </summary>
  184.                 /// <param name="str"></param>
  185.                 /// <param name="maxLength"></param>
  186.                 /// <returns></returns>
  187.                 public static string TrimLength(this string str, int maxLength)
  188.                 {
  189.                         if (str == null)
  190.                         {
  191.                                 return str;
  192.                         }
  193.                         if (str.Length > maxLength)
  194.                         {
  195.                                 str = str.Remove(maxLength);
  196.                         }
  197.                         return str;
  198.                 }
  199.                 //from http://mennan.kagitkalem.com/CommentView,guid,d8e01e32-49f3-4450-994a-990c4fa0a437.aspx
  200.                 //use the most efficient
  201.                 public static int OccurencesCount(string str, string sToFind)
  202.                 {
  203.                         string copyOrginal = String.Copy(str);
  204.                         int place = 0;
  205.                         int numberOfOccurances = 0;
  206.                         place = copyOrginal.IndexOf(sToFind.ToString());
  207.                         while (place != -1)
  208.                         {
  209.                                 copyOrginal = copyOrginal.Substring(place + 1);
  210.                                 place = copyOrginal.IndexOf(sToFind.ToString());
  211.                                 numberOfOccurances++;
  212.                         }
  213.                         return numberOfOccurances;
  214.                 }
  215.                 //case-incensitive replace from http://www.codeproject.com/cs/samples/fastestcscaseinsstringrep.asp?msg=1835929#xx1835929xx
  216.                 static public string Replace(string original, string pattern, string replacement, StringComparison comparisonType)
  217.                 {
  218.                         if (original == null)
  219.                         {
  220.                                 return null;
  221.                         }
  222.  
  223.                         if (String.IsNullOrEmpty(pattern))
  224.                         {
  225.                                 return original;
  226.                         }
  227.  
  228.                         int lenPattern = pattern.Length;
  229.                         int idxPattern = -1;
  230.                         int idxLast = 0;
  231.  
  232.                         StringBuilder result = new StringBuilder();
  233.  
  234.                         while (true)
  235.                         {
  236.                                 idxPattern = original.IndexOf(pattern, idxPattern + 1, comparisonType);
  237.  
  238.                                 if (idxPattern < 0)
  239.                                 {
  240.                                         result.Append(original, idxLast, original.Length - idxLast);
  241.  
  242.                                         break;
  243.                                 }
  244.  
  245.                                 result.Append(original, idxLast, idxPattern - idxLast);
  246.                                 result.Append(replacement);
  247.  
  248.                                 idxLast = idxPattern + lenPattern;
  249.                         }
  250.  
  251.                         return result.ToString();
  252.                 }
  253.                 /// <summary>
  254.                 /// Uses regex '\b' as suggested in //http://stackoverflow.com/questions/6143642/way-to-have-string-replace-only-hit-whole-words
  255.                 /// </summary>
  256.                 /// <param name="original"></param>
  257.                 /// <param name="wordToFind"></param>
  258.                 /// <param name="replacement"></param>
  259.                 /// <param name="regexOptions">e.g. RegexOptions.IgnoreCase</param>
  260.                 /// <returns></returns>
  261.                 static public string ReplaceWholeWord(this string original, string wordToFind, stringreplacement, RegexOptions regexOptions = RegexOptions.None)
  262.                 {
  263.                
  264.                 string  pattern = String.Format(@"\b{0}\b", wordToFind);
  265.                 string ret = Regex.Replace(original, pattern, replacement, regexOptions);
  266.                         return ret;
  267.                 }
  268.                 /// <summary>
  269.                 /// Find the last entry of sToFind and replace it with sToReplace string
  270.                 /// </summary>
  271.                 /// <param name="str"></param>
  272.                 /// <param name="sToFind">if sToFind not found, then original string should be returned.
  273.                 /// if sToFind is empty, the original string should be returned</param>
  274.                 /// <param name="sToReplace"></param>
  275.                 /// <returns></returns>
  276.                 public static string ReplaceLast(this string str, string sToFind, string sToReplace)
  277.                 {
  278.                         StringBuilder builder1 = new StringBuilder(str);
  279.                         int num1 = str.LastIndexOf(sToFind);
  280.                         if (num1 < 0)
  281.                         {
  282.                                 return str;
  283.                         }
  284.                         builder1.Replace(sToFind, sToReplace, num1, sToFind.Length);
  285.                         return builder1.ToString();
  286.                 }
  287.                 public static string IfNotEmptyEnsureEndsWith(string str, string sEndValue)
  288.                 {
  289.                         if (String.IsNullOrEmpty(str)) return str; //21/10/2005
  290.                         if (!str.EndsWith(sEndValue))
  291.                         {
  292.                                 str = str + sEndValue;
  293.                         }
  294.                         return str;
  295.                 }
  296.                 public static string EnsureEndsWith(this string str, string sEndValue)
  297.                 {
  298.                         if (!str.EndsWith(sEndValue))
  299.                         {
  300.                                 str = str + sEndValue;
  301.                         }
  302.                         return str;
  303.                 }
  304.                 //converted from http://stackoverflow.com/questions/1250514/find-length-of-initial-segment-matching-mask-on-arrays
  305.                 public static string LongestCommonPrefix(string str1, string str2)
  306.                 {
  307.                         int minLen = Math.Min(str1.Length, str2.Length);
  308.                         for (int i = 0; i < minLen; i++)
  309.                         {
  310.                                 if (str1[i] != str2[i])
  311.                                 {
  312.                                         return str1.Substring(0, i);
  313.                                 }
  314.                         }
  315.                         return str1.Substring(0, minLen);
  316.                 }
  317.                 /// <summary>
  318.                 ///  Adds Prefix, if it is not exist in the string, case sensitive
  319.                 /// </summary>
  320.                 /// <param name="str">if null, returns prefix</param>
  321.                 /// <param name="sPrefix">if null or empty, returns original string</param>
  322.                 /// <returns></returns>
  323.                 public static string EnsureStartsWith(this string str, string sPrefix)
  324.                 {
  325.                         if (str == null)
  326.                         { //throw new ArgumentNullException("str");
  327.                                 return sPrefix;
  328.                         }
  329.                         if (!String.IsNullOrEmpty(sPrefix))
  330.                         {
  331.                                 if (!str.StartsWith(sPrefix))
  332.                                 {
  333.                                         str = sPrefix + str;
  334.                                 }
  335.                         }
  336.                         return str;
  337.                 }
  338.                 public static string AppendWithDelimeter(string str, string sToAppend, string delimeter)
  339.                 {
  340.                         if ((!str.EndsWith(delimeter) & !String.IsNullOrEmpty(str)) &!String.IsNullOrEmpty(sToAppend))
  341.                         {
  342.                                 str = str + delimeter;
  343.                         }
  344.                         str = str + sToAppend;
  345.                         return str;
  346.                 }
  347.                 public static string AppendIfNotContains(string str, string sToAppend, string delimeter)
  348.                 {
  349.                         if (!str.Contains(sToAppend))
  350.                         {
  351.                                 str = AppendWithDelimeter(str, sToAppend, delimeter);
  352.                         }
  353.                         return str;
  354.                 }
  355.                 public static string AppendIfNotEmpty(this string str, string prefixBeforeAppend,stringvalueToAppend,string suffixAfterAppend="")
  356.                 {
  357.                         if (!String.IsNullOrEmpty(valueToAppend))
  358.                         {
  359.                                 str += prefixBeforeAppend + valueToAppend + suffixAfterAppend;
  360.                         }
  361.                         return str;
  362.                 }
  363.                 //from http://66.102.7.104/search?q=cache:DSw2bnf_FlMJ:blogs.msdn.com/brada/archive/2004/02/16/73535.aspx+%22EndsWith+char+%22+string+C%23&hl=en
  364.                 //" internal bool EndsWith(char value) in String class. Why it would be internal? Also, there is no bool StartsWith(char value). "
  365.                 public static bool EndsWith(string str, char value)
  366.                 {
  367.                         int num1 = str.Length;
  368.                         if ((num1 != 0) && (str[num1 - 1] == value))
  369.                         {
  370.                                 return true;
  371.                         }
  372.                         return false;
  373.                 }
  374.                 public static bool StartsWith(string str, char value)
  375.                 {
  376.                         if ((str.Length != 0) && (str[0] == value))
  377.                         {
  378.                                 return true;
  379.                         }
  380.                         return false;
  381.                 }
  382.                 #region Case conversions
  383.  
  384.                 /// <summary>
  385.                 ///
  386.                 /// </summary>
  387.                 /// <param name="input"></param>
  388.                 /// <returns></returns>
  389.                 /// <remarks>
  390.                 /// from http://dotnetjunkies.com/WebLog/davetrux/archive/2006/05/22/138692.aspx, http://west-wind.com/weblog/posts/361.aspx
  391.                 ///  http://www.logiclabz.com/c/title-case-proper-case-function-in-net-c.aspx
  392.                 /// use TextInfo.ToTitleCase(mText.ToLower());
  393.                 /// Alternative see From http://aspcode.net/propercase-function-in-c/
  394.                 ///     </remarks>
  395.                 public static string ToTitleCase(this string input)
  396.                 {
  397.                         input = input.ToLower();
  398.                         return Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(input);
  399.  
  400.                 }
  401.                 public static string ToCamelCase(this string s)
  402.                 {
  403.                         var sb = new StringBuilder();
  404.                         char[] ca = s.ToLower().ToCharArray();
  405.                         for (int i = 0; i < ca.Length; i++)
  406.                         {
  407.                                 char c = ca[i];
  408.                                 if (i == 0 || Char.IsSeparator(ca[i - 1]))
  409.                                 {
  410.                                         c = Char.ToUpper(c);
  411.                                 }
  412.                                 sb.Append(c);
  413.                         }
  414.  
  415.                         return sb.ToString();
  416.                 }
  417.                 /// <summary>
  418.                 /// Convert string from pascal case to human readable string
  419.                 /// <example>pascalCaseExample => Pascal Case Example</example>
  420.                 /// </summary>
  421.                 /// <param name="s">The string</param>
  422.                 /// <returns>human readable string</returns>
  423.                 public static string ToHumanFromPascal(string s)
  424.                 {
  425.                         StringBuilder sb = new StringBuilder();
  426.                         char[] ca = s.ToCharArray();
  427.                         sb.Append(ca[0]);
  428.                         for (int i = 1; i < ca.Length - 1; i++)
  429.                         {
  430.                                 char c = ca[i];
  431.                                 if (Char.IsUpper(c) && (Char.IsLower(ca[i + 1]) || Char.IsLower(ca[i - 1])))
  432.                                 {
  433.                                         sb.Append(" ");
  434.                                 }
  435.                                 sb.Append(c);
  436.                         }
  437.                         sb.Append(ca[ca.Length - 1]);
  438.  
  439.                         return sb.ToString();
  440.                 }
  441.  
  442.                 #endregion //Case conversions
  443.                 //Alternatively see http://weblogs.asp.net/sushilasb/archive/2006/08/03/How-to-extract-numbers-from-string.aspx
  444.                 public static string GetStartingNumericFromString(string itmName)
  445.                 {
  446.                         string safeNumericString = "";
  447.                         foreach (char s in itmName)
  448.                         {
  449.                                 if (s.CompareTo('0') < 0 || s.CompareTo('9') > 0)
  450.                                 {
  451.                                         break;
  452.                                 }
  453.                                 safeNumericString += s.ToString();
  454.                         }
  455.                         return safeNumericString;
  456.                 }
  457.  
  458.                 /// <summary>
  459.                 /// method for removing all whitespace from a given string
  460.                 /// </summary>
  461.                 /// <param name="str">string to strip</param>
  462.                 /// <returns></returns>
  463.                 public static string RemoveAllWhitespace(string str)
  464.                 {
  465.                         Regex reg = new Regex(@"\s*");
  466.                         str = reg.Replace(str, "");
  467.                         return str;
  468.                 }
  469.  
  470.                 /*From http://bytes.com/topic/c-sharp/answers/253519-using-regex-create-sqls-like-like-function
  471.                  * Ex:
  472. *
  473. * bool isMatch =
  474. * IsSqlLikeMatch("abcdef", "[az]_%[^qz]ef");
  475. *
  476. * should return true.
  477. */
  478.                 /// <summary>
  479.                 /// Note that it could be very serious performance hit, if the pattern is started with %.
  480.                 /// </summary>
  481.                 /// <param name="input"></param>
  482.                 /// <param name="pattern"></param>
  483.                 /// <returns></returns>
  484.                 public static bool IsSqlLikeMatch(this string input, string pattern)
  485.                 {
  486.                         /* Turn "off" all regular expression related syntax in
  487.                         * the pattern string. */
  488.                         pattern = Regex.Escape(pattern);
  489.  
  490.                         /* Replace the SQL LIKE wildcard metacharacters with the
  491.                         * equivalent regular expression metacharacters. */
  492.                         pattern = pattern.Replace("%", ".*?").Replace("_", ".");
  493.  
  494.                         /* The previous call to Regex.Escape actually turned off
  495.                         * too many metacharacters, i.e. those which are recognized by
  496.                         * both the regular expression engine and the SQL LIKE
  497.                         * statement ([...] and [^...]). Those metacharacters have
  498.                         * to be manually unescaped here. */
  499.                         pattern = pattern.Replace(@"\[", "[").Replace(@"\]", "]").Replace(@"\^", "^");
  500.  
  501.                         return Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase |RegexOptions.Singleline);
  502.                 }
  503.  
  504.         /// <summary>
  505.         /// Determines whether [contains] [the specified source] with string comparison.
  506.         /// </summary>
  507.         /// <param name="source">The source.</param>
  508.         /// <param name="toCheck">To check.</param>
  509.         /// <param name="comp">The comp.</param>
  510.         /// <returns>
  511.         ///   <c>true</c> if [contains] [the specified source]; otherwise, <c>false</c>.
  512.         /// </returns>
  513.         public static bool Contains(this string source, string toCheck, StringComparison comp)
  514.         {
  515.             return source.IndexOf(toCheck, comp) >= 0;
  516.         }
  517.  
  518.  
  519.                 #endregion //"String Functions"
  520.  
  521.                 #region "String Array Functions"
  522.                 public static string[] ToLower(string[] sArray)
  523.                 {
  524.                         for (int i = 0; i < sArray.Length; i++)
  525.                         {
  526.                                 sArray[i] = sArray[i].ToLower();
  527.                         }
  528.                         return sArray;
  529.                 }
  530.                 //see also a few methods in http://www.codeproject.com/csharp/StringBuilder_vs_String.asp
  531.                 public static string Join(string separator, params string[] list)
  532.                 {
  533.                         return String.Join(separator, list);
  534.                 }
  535.                 #endregion //"String Array Functions"
  536.  
  537.  
  538.                 #region "String Brackets Functions"
  539.                 //             
  540.                 /// <summary>
  541.                 /// 'StripBrackets checks that starts from sStart and ends with sEnd (case sensitive).
  542.                 ///             'If yes, than removes sStart and sEnd.
  543.                 ///             'Otherwise returns full string unchanges
  544.                 ///             'See also MidBetween
  545.                 /// </summary>
  546.                 /// <param name="str"></param>
  547.                 /// <param name="sStart"></param>
  548.                 /// <param name="sEnd"></param>
  549.                 /// <returns></returns>
  550.                 public static string StripBrackets(string str, string sStart, string sEnd)
  551.                 {
  552.                         if (CheckBrackets(str, sStart, sEnd))
  553.                         {
  554.                                 str = str.Substring(sStart.Length, (str.Length - sStart.Length) -sEnd.Length);
  555.                         }
  556.                         return str;
  557.                 }
  558.                 public static bool CheckBrackets(string str, string sStart, string sEnd)
  559.                 {
  560.                         bool flag1 = false;
  561.                         if ((str != null) && (str.StartsWith(sStart) && str.EndsWith(sEnd)))//19/5/ null handling
  562.                         {
  563.                                 flag1 = true;
  564.                         }
  565.                         return flag1;
  566.                 }
  567.  
  568.                 public static string WrapBrackets(string str, string sStartBracket, string sEndBracket)
  569.                 {
  570.                         StringBuilder builder1 = new StringBuilder(sStartBracket);
  571.                         builder1.Append(str);
  572.                         builder1.Append(sEndBracket);
  573.                         return builder1.ToString();
  574.                 }
  575.                 //    'Concatenates a specified separator String between each element of a specified String array wrapping each element, yielding a single concatenated string
  576.                 public static string JoinWrapBrackets(string[] aStr, string sDelimeter, string sStartBracket,string sEndBracket)
  577.                 {
  578.                         StringBuilder builder1 = new StringBuilder();
  579.                         string[] textArray1 = aStr;
  580.                         for (int num1 = 0; num1 < textArray1.Length; num1++)
  581.                         {
  582.                                 string text2 = textArray1[num1];
  583.                                 builder1.Append(WrapBrackets(text2, sStartBracket, sEndBracket));
  584.                                 builder1.Append(sDelimeter);
  585.                         }
  586.                         return TrimEnd(builder1.ToString(), sDelimeter);
  587.                 }
  588.                 /// <summary>
  589.                 ///
  590.                 /// </summary>
  591.                 /// <param name="thisString"></param>
  592.                 /// <param name="openTag"></param>
  593.                 /// <param name="closeTag"></param>
  594.                 /// <param name="transform"></param>
  595.                 /// <returns></returns>
  596.                 /// <example>
  597.                 ///     // mask <AccountNumber>XXXXX4488</AccountNumber>
  598.                 ///requestAsString  = requestAsString.ReplaceBetweenTags("<AccountNumber>", "</AccountNumber>", CreditCard.MaskedCardNumber);
  599.                 ///mask cvv
  600.                 ///requestAsString = requestAsString.ReplaceBetweenTags("<FieldName>CC::VerificationCode</FieldName><FieldValue>", "</FieldValue>", cvv=>"XXX");
  601.                 /// </example>
  602.                 public static string ReplaceBetweenTags(this string thisString, string openTag, stringcloseTag, Func<string, string> transform)
  603.                 {
  604.                         //See also http://stackoverflow.com/questions/1359412/c-sharp-remove-text-in-between-delimiters-in-a-string-regex
  605.                         string sRet = thisString;
  606.                         string between = thisString.MidBetween(openTag, closeTag, true);
  607.                         if (!String.IsNullOrEmpty(between))
  608.                                 sRet=thisString.Replace(openTag + between + closeTag, openTag +transform(between) + closeTag);
  609.                         return sRet;
  610.                 }
  611.                 public static string ReplaceBetweenTags(this string thisString, string openTag, stringcloseTag, string newValue)
  612.                 {
  613.                         //See also http://stackoverflow.com/questions/1359412/c-sharp-remove-text-in-between-delimiters-in-a-string-regex
  614.                         string sRet = thisString;
  615.                         string between = thisString.MidBetween(openTag, closeTag, true);
  616.                         if (!String.IsNullOrEmpty(between))
  617.                                 sRet = thisString.Replace(openTag + between + closeTag, openTag + newValue +closeTag);
  618.                         return sRet;
  619.                 }
  620.  
  621.                 //              ' Quote the arguments, in case they have a space in them.
  622.                 public static string QuotePath(string sPath)
  623.                 {
  624.                         return ("\"" + sPath + "\"");
  625.                 }
  626.                 public static string DblQuoted(string sWord)
  627.                 {
  628.                         sWord = Strings.Replace(sWord, "\"", "\"\"", 1, -1, CompareMethod.Binary);
  629.                         return ("\"" + sWord + "\"");
  630.                 }
  631.                 #endregion //"String Brackets Functions"
  632.  
  633.                 /// <summary>
  634.                 /// Returns true, if  string contains any of substring from the list (case insensitive)
  635.                 /// See similar (with SqlLikeMatch support) in ResponseMessagePatternsCache
  636.                 /// </summary>
  637.                 /// <returns></returns>
  638.                 public static bool IsStringContainsAnyFromList(this string stringToSearch,List<String>stringsToFind)
  639.                 {
  640.                         //TODO: create overloads with exact match  or case sencitive
  641.                         if (stringsToFind.IsNullOrEmpty())
  642.                         { return false; }
  643.                         else
  644.                         {
  645.                                 stringToSearch = stringToSearch.ToUpper();
  646.                                 return stringsToFind.Any(pattern =>stringToSearch.Contains(pattern.ToUpper()));
  647.                         }
  648.                 }
  649.         }
  650. }

v   

posted @ Thursday, July 13, 2006 8:16 AM
Print

Comments on this entry:

# re: My StringHelper class

Left by MMORPG Runescape Forums at 10/18/2008 9:39 AM
Gravatar
very nice :D thanks

Your comment:



(not displayed)

 
 
 
 
 

Live Comment Preview:

 
«September»
SunMonTueWedThuFriSat
31123456
78910111213
14151617181920
21222324252627
2829301234
567891011