C# 4 and .NET 4

210 ❘ ChaPTer 9 strinGs And reGulAr expressiOns
For simplicity, this code does not wrap Z to A or z to a. These letters get encoded to
[ and { , respectively.
In this example, the Replace() method works in a fairly intelligent way, to the extent that it won ’ t actually
create a new string unless it actually makes changes to the old string. The original string contained 23
different lowercase characters and 3 different uppercase ones. The Replace() method will therefore have
allocated a new string 26 times in total, with each new string storing 103 characters. That means that
because of the encryption process, there will be string objects capable of storing a combined total of 2,678
characters now sitting on the heap waiting to be garbage - collected! Clearly, if you use strings to do text
processing extensively, your applications will run into severe performance problems.
To address this kind of issue, Microsoft has supplied the System.Text.StringBuilder class. StringBuilder
is not as powerful as String in terms of the number of methods it supports. The processing you can do on a
StringBuilder is limited to substitutions and appending or removing text from strings. However, it works in
a much more effi cient way.
When you construct a string using the String class, just enough memory is allocated to hold the string. The
StringBuilder , however, normally allocates more memory than is actually needed. You, as a developer,
have the option to indicate how much memory the StringBuilder should allocate, but if you do not, the
amount will default to some value that depends on the size of the string that the StringBuilder instance is
initialized with. The StringBuilder class has two main properties:
➤
➤
Length , which indicates the length of the string that it actually contains
Capacity , which indicates the maximum length of the string in the memory allocation
Any modifi cations to the string take place within the block of memory assigned to the StringBuilder
instance, which makes appending substrings and replacing individual characters within strings very
effi cient. Removing or inserting substrings is inevitably still ineffi cient because it means that the following
part of the string has to be moved. Only if you perform some operation that exceeds the capacity of the
string is it necessary to allocate new memory and possibly move the entire contained string. In adding
extra capacity, based on our experiments the StringBuilder appears to double its capacity if it detects the
capacity has been exceeded and no new value for the capacity has been set.
For example, if you use a StringBuilder object to construct the original greeting string, you might
write this code:
StringBuilder greetingBuilder =
new StringBuilder("Hello from all the guys at Wrox Press. ", 150);
greetingBuilder.AppendFormat("We do hope you enjoy this book as much as we enjoyed
writing it");
To use the StringBuilder class, you need a System.Text reference in your code.
This code sets an initial capacity of 150 for the StringBuilder . It is always a good idea to set some
capacity that covers the likely maximum length of a string, to ensure the StringBuilder does not need to
relocate because its capacity was exceeded. By default, the capacity is set to 16. Theoretically, you can set as
large a number as you can pass in an int , although the system will probably complain that it does not have
enough memory if you actually try to allocate the maximum of two billion characters (this is the theoretical
maximum that a StringBuilder instance is allowed to contain, in principle).
When the preceding code is executed, it fi rst creates a StringBuilder object that looks like Figure 9 - 1.
www.it-ebooks.info