C# 4 and .NET 4

214 ❘ ChaPTer 9 strinGs And reGulAr expressiOns
How the string is formatted
As an example of how strings are formatted, if you execute the following statement:
Console.WriteLine("The double is {0,10:E} and the int contains {1}", d, i);
Console.WriteLine() just passes the entire set of parameters to the static method, String.Format().
This is the same method that you would call if you wanted to format these values for use in a string to be
displayed in a text box, for example. The implementation of the three-parameter overload of WriteLine()
basically does this:
// Likely implementation of Console.WriteLine()
public void WriteLine(string format, object arg0, object arg1)
{
this.WriteLine(string.Format(this.FormatProvider, format,
new object[]{arg0, arg1}));
}
The one-parameter overload of this method, which is in turn called in the preceding code sample, simply
writes out the contents of the string it has been passed, without doing any further formatting on it.
String.Format() now needs to construct the final string by replacing each format specifier with a
suitable string representation of the corresponding object. However, as you saw earlier, for this process of
building up a string you need a StringBuilder instance rather than a string instance. In this example,
a StringBuilder instance is created and initialized with the first known portion of the string, the text
“The double is”. Next, the StringBuilder.AppendFormat() method is called, passing in the first
format specifier, {0,10:E}, as well as the associated object, double, to add the string representation of this
object to the string object being constructed. This process continues with StringBuilder.Append() and
StringBuilder.AppendFormat() being called repeatedly until the entire formatted string has
been obtained.
Now comes the interesting part: StringBuilder.AppendFormat() has to figure out how to format the
object. First, it probes the object to find out whether it implements an interface in the System namespace
called IFormattable. You can determine this quite simply by trying to cast an object to this interface and
seeing whether the cast succeeds, or by using the C# is keyword. If this test fails, AppendFormat() calls
the object’s ToString() method, which all objects either inherit from System.Object or override. This is
exactly what happens here because none of the classes written so far has implemented this interface.
That is why the overrides of Object.ToString() have been sufficient to allow the structs and classes from
earlier chapters such as Vector to get displayed in Console.WriteLine() statements.
However, all the predefined primitive numeric types do implement this interface, which means that for
those types, and in particular for double and int in the example, the basic ToString() method inherited
from System.Object will not be called. To understand what happens instead, you need to examine the
IFormattable interface.
IFormattable defines just one method, which is also called ToString(). However, this method takes two
parameters as opposed to the System.Object version, which doesn’t take any parameters. The following
code shows the definition of IFormattable:
interface IFormattable
{
string ToString(string format, IFormatProvider formatProvider);
}
The first parameter that this overload of ToString() expects is a string that specifies the requested format.
In other words, it is the specifier portion of the string that appears inside the braces ({}) in the string
originally passed to Console.WriteLine() or String.Format(). For example, in the example the original
statement was:
Console.WriteLine("The double is {0,10:E} and the int contains {1}", d, i);
www.it-ebooks.info