This code string extension will take a specific number of words and create a list of strings up to that word boundary. For example if one split on this sentence: “The Fall River” would make three strings of “The “, “Fall “ and “River”.
I have placed this into a string extension which could be called such as
List<string> items = "The Fall River".SplitOn( 5 );
Here is the extension method
// using System.Text.RegularExpressions;
public static class StringExtensions
{
/// <summary>Use this function like string.Split but instead of a character to split on,
/// use a maximum line width size. This is similar to a Word Wrap where no words will be split.</summary>
/// Note if the a word is longer than the maxcharactes it will be trimmed from the start.
/// <param name="initial">The string to parse.</param>
/// <param name="MaxCharacters">The maximum size.</param>
/// <remarks>This function will remove some white space at the end of a line, but allow for a blank line.</remarks>
///
/// <returns>An array of strings.</returns>
public static List<string> SplitOn( this string initial, int MaxCharacters )
{
List<string> lines = new List<string>();
if ( string.IsNullOrEmpty( initial ) == false )
{
string targetGroup = "Line";
string theRegex = string.Format( @"(?<{0}>.{{1,{1}}})(?:\W|$)", targetGroup, MaxCharacters );
MatchCollection matches = Regex.Matches( initial, theRegex, RegexOptions.IgnoreCase
| RegexOptions.Multiline
| RegexOptions.ExplicitCapture
| RegexOptions.CultureInvariant
| RegexOptions.Compiled );
if ( matches != null )
if ( matches.Count > 0 )
foreach ( Match m in matches )
lines.Add( m.Groups[targetGroup].Value );
}
return lines;
}
}
Here is an example with output of its usage:
string text = "The rain in spain falls mainly on the plain of Jabberwocky falls.";
List<string> lines = text.SplitOn( 20 );
foreach ( string line in lines )
Console.WriteLine( line );
/*
The rain in spain
falls mainly on the
plain of Jabberwocky
falls.
*/
foreach ( string line in text.SplitOn( 11 ) )
Console.WriteLine( line );
/*
The rain in
spain falls
mainly on
the plain
of
Jabberwocky
falls.
*/
I had written a post a while back which detailed a regular expression pattern used by the .Net regex parser which parsed a Comma Separated Value file, or a CSV file for short. Upon looking at the pattern I came to realize that the pattern didn’t work for all situations. So I have created a new pattern which will extract all items from the CSV data into into a dynamic anonymous Linq entity. Following that example I will show one how to use the same Linq entity to put that CSV data into a dictionary, a hash table, where the key of entry is the first column’s data.
What if you are stuck having to deal with older technology such as INI files while using the latest and greatest C# and .Net there is available? This article discusses an alternate way to read INI files and extract the data from those dusty tomes while easily accessing the resulting data from dictionaries. Once the data resides in the dictionaries we can easily extract the data using the power of the indexer on section name followed by key name within the section. Such as IniFile[“TargetSection”][“TargetKey”] which will return a string of the value of that key in the ini file for that section. 
It is generally accepted that there is an overhead in using regular expression parsing and there is truth to that statement. But the premise of this article is that the difference is really negligible and if its an excuse to not learn regex pattern processing because of that, well that is just plain foolish. Just like any high level language programming construct which gives the developer a quicker development time, the price paid is in extra cycles it takes to complete it. But is the perception that usage of regular expressions are really that slow? Let me show you by example….
