C# 4 and .NET 4

egular expressions ❘ 219
Suppose your application needed to convert U.S. phone numbers to an international format. In the United
States, the phone numbers have this format: 314 - 123 - 1234, which is often written as (314) 123 - 1234. When
converting this national format to an international format you have to include +1 (the country code of the
United States) and add brackets around the area code: +1 (314) 123 - 1234. As fi nd - and - replace operations
go, that is not too complicated. It would still require some coding effort if you were going to use the String
class for this purpose (which would mean that you would have to write your code using the methods
available from System.String ). The regular expressions language allows you to construct a short string
that achieves the same result.
This section is intended only as a very simple example, so it concentrates on searching strings to identify
certain substrings, not on modifying them.
The regularexpressionsPlayaround example
For the rest of this section, you develop a short example, called RegularExpressionsPlayaround, that
illustrates some of the features of regular expressions and how to use the .NET regular expressions engine in
C# by performing and displaying the results of some searches. The text you are going to use as your sample
document is an introduction to a Wrox Press book on ASP.NET ( Professional ASP.NET 4: in C# and VB,
Wiley Publishing, 2010, ISBN 978 - 0 - 470 5-0220-4).
const string myText =
@"This comprehensive compendium provides a broad and thorough investigation of all
aspects of programming with ASP.NET. Entirely revised and updated for the fourth
release of .NET, this book will give you the information you need to
master ASP.NET and build a dynamic, successful, enterprise Web application.";
code snippet RegularExpressionsPlayaround.cs
This code is valid C# code, despite all the line breaks. It nicely illustrates the utility of
verbatim strings that are prefi xed by the @ symbol.
This text is referred to as the input string. To get your bearings and get used to the regular expressions of
.NET classes, you start with a basic plain text search that does not feature any escape sequences or regular
expression commands. Suppose that you want to fi nd all occurrences of the string ion . This search string
is referred to as the pattern. Using regular expressions and the Text variable declared previously, you could
write this:
const string pattern = "ion";
MatchCollection myMatches = Regex.Matches(myText, pattern,
RegexOptions.IgnoreCase |
RegexOptions.ExplicitCapture);
foreach (Match nextMatch in myMatches)
{
Console.WriteLine(nextMatch.Index);
}
This code uses the static method Matches() of the Regex class in the System.Text.RegularExpressions
namespace. This method takes as parameters some input text, a pattern, and a set of optional fl ags taken
from the RegexOptions enumeration. In this case, you have specifi ed that all searching should be case -
insensitive. The other fl ag, ExplicitCapture , modifi es the way that the match is collected in a way that, for
your purposes, makes the search a bit more effi cient — you see why this is later (although it does have other
uses that we won ’ t explore here). Matches() returns a reference to a MatchCollection object. A match
is the technical term for the results of fi nding an instance of the pattern in the expression. It is represented
by the class System.Text.RegularExpressions.Match . Therefore, you return a MatchCollection that
contains all the matches, each represented by a Match object. In the preceding code, you simply iterate over
the collection and use the Index property of the Match class, which returns the index in the input text of
www.it-ebooks.info