C# 4 and .NET 4

220 ❘ ChaPTer 9 strinGs And reGulAr expressiOns
where the match was found. Running this code results in three matches. The following table details some of
the RegexOptions enumerations.
member name
CultureInvariant
ExplicitCapture
IgnoreCase
IgnorePatternWhitespace
Multiline
RightToLeft
Singleline
desCriPTion
Specifies that the culture of the string is ignored.
Modifies the way the match is collected by making sure that valid captures
are the ones that are explicitly named.
Ignores the case of the string that is input.
Removes unescaped whitespace from the string and enables comments that
are specified with the pound or hash sign.
Changes the characters ^ and $ so that they are applied to the beginning and
end of each line and not just to the beginning and end of the entire string.
Causes the inputted string to be read from right to left instead of the default
left to right (ideal for some Asian and other languages that are read in this
direction).
Specifies a single-line mode where the meaning of the dot (.) is changed to
match every character.
So far, nothing is new from the preceding example apart from some .NET base classes. However, the power
of regular expressions really comes from that pattern string. The reason is that the pattern string does not
have to contain only plain text. As hinted earlier, it can also contain what are known as meta-characters,
which are special characters that give commands, as well as escape sequences, which work in much the same
way as C# escape sequences. They are characters preceded by a backslash (\) and have special meanings.
For example, suppose that you wanted to find words beginning with n. You could use the escape sequence
\b, which indicates a word boundary (a word boundary is just a point where an alphanumeric character
precedes or follows a whitespace character or punctuation symbol). You would write this:
const string pattern = @"\bn";
MatchCollection myMatches = Regex.Matches(myText, pattern,
RegexOptions.IgnoreCase |
RegexOptions.ExplicitCapture);
Notice the @ character in front of the string. You want the \b to be passed to the .NET regular expressions
engine at runtime — you don’t want the backslash intercepted by a well-meaning C# compiler that thinks
it’s an escape sequence intended for itself! If you want to find words ending with the sequence ion, you
write this:
const string pattern = @"ion\b";
If you want to find all words beginning with the letter a and ending with the sequence ion (which has as its
only match the word application in the example), you will have to put a bit more thought into your code.
You clearly need a pattern that begins with \ba and ends with ion\b, but what goes in the middle You
need to somehow tell the application that between the a and the ion there can be any number of characters
as long as none of them are whitespace. In fact, the correct pattern looks like this:
const string pattern = @"\ba\S*ion\b";
Eventually you will get used to seeing weird sequences of characters like this when working with regular
expressions. It actually works quite logically. The escape sequence \S indicates any character that is not a
whitespace character. The * is called a quantifier. It means that the preceding character can be repeated any
number of times, including zero times. The sequence \S* means any number of characters as long as they
are not whitespace characters. The preceding pattern will, therefore, match any single word that begins
with a and ends with ion.
www.it-ebooks.info