The .NET Base Class Library (BCL) contains many functions normally found in language-specific runtime libraries. It is therefore important to understand what classes are available in the BCL.

Numeric Formatting

Numeric types are formatted through the Format() member function of that data type. This can be called directly, through String.Format(), which calls the Format() function of each data type, or through Console.WriteLine(), which calls String.Format().

Adding formatting to a user-defined object is discussed in the “Custom Object Formatting” section later in this chapter. This section discusses how formatting is done with the built-in types.

There are two methods of specifying numeric formatting. A standard format string can be used to convert a numeric type to a specific string representation. If further control over the output is desired, a custom format string can be used.

Console.WriteLine("{0:C}", 33345.8977);
Console.WriteLine("{0:C}", -33345.8977);

$33,345.90
($33,345.90)

Console.WriteLine("{0:D}", 33345);
Console.WriteLine("{0:D7}", 33345);

33345
0033345

m.dddE + xxx

Console.WriteLine("{0:E}", 33345.8977);
Console.WriteLine("{0:E10}", 33345.8977);
Console.WriteLine("{0:e4}", 33345.8977);

3.334590E + 004
3.3345897700E + 004
3.3346e + 004

Console.WriteLine("{0:F}", 33345.8977);
Console.WriteLine("{0:F0}", 33345.8977);
Console.WriteLine("{0:F5}", 33345.8977);

33345.90
33346
33345.89770

Console.WriteLine("{0:G}", 33345.8977);
Console.WriteLine("{0:G7}", 33345.8977);
Console.WriteLine("{0:G4}", 33345.8977);

33345.8977
33345.9
3.335E + 04

12,345.11

Console.WriteLine("{0:N}", 33345.8977);
Console.WriteLine("{0:N4}", 33345.8977);

33,345.90
33,345.8977

class RoundTrip
{
    public static void Main()
    {
       Random random = new Random();
       while (true)
       {
            double value = random.NextDouble();
            if (value != ToStringAndBack(value))
            {
                Console.WriteLine("Different: {0}", value);
            }
       }
    }
    public static double ToStringAndBack(double value)
    {
       string valueAsString = value.ToString();
       return Double.Parse(valueAsString);
    }
}

string valueAsString = value.ToString("R");

Console.WriteLine("{0:X}", 255);
Console.WriteLine("{0:x8}", 1456);

FF
000005b0

Console.WriteLine("{0:000}", 55);
Console.WriteLine("{0:000}", 1456);

055
1456

Console.WriteLine("{0:#####}", 255);
Console.WriteLine("{0:#####}", 1456);
Console.WriteLine("{0:###}", 32767);

255
1456
32767

Console.WriteLine("{0:#####.000}", 75928.3);
Console.WriteLine("{0:##.000}", 1456.456456);

75928.300
1456.456

Console.WriteLine("{0:##,###}", 2555634323);
Console.WriteLine("{0:##,000.000}", 14563553.593993);
Console.WriteLine("{0:#,#.000}", 14563553.593993);

2,555,634,323
14,563,553.594
14,563,553.594

Console.WriteLine("{0:000,.##}", 158847);
Console.WriteLine("{0:000,,,.###}", 1593833);

158.85
000.002

Console.WriteLine("{0:##.000 %}", 0.89144);
Console.WriteLine("{0:00 %}", 0.01285);

89.144 %
01 %

Console.WriteLine("{0:###.000E-00}", 3.1415533E + 04);
Console.WriteLine("{0:#.0000000E + 000}", 2.553939939E + 101);

314.155E-02
2.5539399E + 101

Console.WriteLine("{0:###.00;0;(###.00)}", -456.55);
Console.WriteLine("{0:###.00;0;(###.00)}", 0);
Console.WriteLine("{0:###.00;0;(###.00)}", 456.55);

457
(.00)
456.55

Console.WriteLine("{0:###\#}", 255);
Console.WriteLine(@"{0:####}", 255);
Console.WriteLine("{0:###'#0 %;'}", 1456);

255#
255#
1456#0 %;

Date and Time Formatting

The DateTime class provides flexible formatting options. Several single-character formats can be specified, and custom formatting is also supported. Table 38-3 specifies the standard DateTime formats.

Custom Object Formatting

Earlier examples have overridden the ToString() function to provide a string representation of a function. An object can supply different formats by defining the IFormattable interface and then changing the representation based upon the string of the function.

For example, an employee class could add additional information with a different format string. This example:

using System;
class Employee: IFormattable
{
    public Employee(int id, string firstName, string lastName)
    {
       m_id = id;
       m_firstName = firstName;
       m_lastName = lastName;
    }
    public string ToString (string format, IFormatProvider fp)
    {
       if ((format != null) && (format.Equals("F")))
       {
            return String.Format("{0}: {1}, {2}",
                m_id, m_lastName, m_firstName);
       }
       else
       {
            return(m_id.ToString(format, fp));
       }
    }
    int m_id;
    string m_firstName;
    string m_lastName;
}
class Test
{
    public static void Main()
    {
       Employee fred = new Employee(123, "Fred", "Morthwaite");
       Console.WriteLine("No format: {0}", fred);
       Console.WriteLine("Full format: {0:F}", fred);
    }
}

produces the following output:

No format: 123
Full format: 123: Morthwaite, Fred

The ToString() function looks for the F format. If it finds it, it writes out the full information. If it doesn’t find it, it uses the default format for the object.

The Main() function passes the format flag in the second WriteLine() call.

Numeric Parsing

Numbers are parsed using the Parse() method provided by the numeric data types. Flags from the NumberStyles class can be passed to specify which styles are allowed, and a NumberFormatInfo instance can be passed to control parsing.

A numeric string produced by any of the standard format specifiers (excluding hexadecimal) is guaranteed to be correctly parsed if the NumberStyles.Any style is specified. This example:

using System;
class Test
{
    public static void Main()
    {
       int value = Int32.Parse("99953");
       double dval = Double.Parse("1.3433E + 35");
       Console.WriteLine("{0}", value);
       Console.WriteLine("{0}", dval);
    }
}

produces the following output:

99953
1.3433E35

Console.WriteLine("Please enter an integer and press Enter");
int numberEntered;
while(!int.TryParse(Console.ReadLine(), out numberEntered))
{
    Console.WriteLine("Please try again");
}
Console.WriteLine("You entered " + numberEntered.ToString());

Input and Output

The .NET Common Language Runtime provides I/O functions in the System.IO namespace. This namespace contains classes for doing I/O and for other I/O-related functions, such as directory traversal, file watching, and so on.

Reading and writing are done using the Stream class, which merely describes how bytes can be read and written to some sort of backing store. Stream is an abstract class, so in practice classes derived from Stream will be used. Table 38-5 lists the available stream classes.

With the exception of BufferedStream, GZipStream, and DeflateStream, which sit on top of another stream, each stream defines where the written data will go.

The Stream class provides raw functions to read and write at a byte level, both synchronously and asynchronously. Usually, however, it’s nice to have a higher-level interface on top of a stream, and there are several supplied ones that can be selected depending on what final format is desired.

using System.IO.Ports;
...
byte[] buffer = new byte[256];
using (SerialPort sp = new SerialPort("COM1", 19200))
{
    sp.Open();
    //read directly
    sp.Read(buffer, 0, (int)buffer.Length);
    //read using a Stream
    sp.BaseStream.Read(buffer, 0, (int)buffer.Length);}

using (StreamWriter writer = File.CreateText("output.txt"))
{
    writer.WriteLine("{0} {1}", "test", 55);
}

using (StreamReader reader = File.OpenText("output.txt"))
{
    string line = reader.ReadLine();
    Console.WriteLine(line);
}

public static class DirectoryWalker
{
    public static void DoWalk(
       Action <DirectoryInfo, int> directoryCallback,
       Action <FileInfo, int> fileCallback,
       string rootDirectory)
    {
       DoWalk(
            directoryCallback,
            fileCallback,
            new DirectoryInfo(rootDirectory),
            0);
    }
    static void DoWalk(
       Action <DirectoryInfo, int> directoryCallback,
       Action <FileInfo, int> fileCallback,
       DirectoryInfo dir,
       int level)
    {
       foreach (FileInfo file in dir.EnumerateFiles())
       {
            if (fileCallback != null)
            {
                fileCallback(file, level);
            }
       }
       foreach (DirectoryInfo directory in dir.EnumerateDirectories())
       {
            if (directoryCallback != null)
            {
                directoryCallback(directory, level);
            }
            DoWalk(directoryCallback, fileCallback, directory, level + 1);
       }
    }
}
public class DirectoryWalkerTest
{
    public static void PrintDir(DirectoryInfo d, int level)
    {
       Console.WriteLine(new string(' ', level * 2));
       Console.WriteLine("Dir: {0}", d.FullName);
    }
    public static void PrintFile(FileInfo f, int level)
    {
       Console.WriteLine(new string(' ', level * 2));
       Console.WriteLine("File: {0}", f.FullName);
    }
    public static void Main()
    {
       DirectoryWalker.DoWalk(
            PrintDir,
            PrintFile,
            "..");
    }
}

using System.Diagnostics;
class Test
{
    public static void Main()
    {
       ProcessStartInfo startInfo = new ProcessStartInfo();
       startInfo.FileName = "notepad.exe";
       startInfo.Arguments = "process.cs";
       Process.Start(startInfo);
    }
}

using System;
using System.Diagnostics;
class Test
{
    public static void Main()
    {
       Process process = new Process();
       process.StartInfo.FileName = "cmd.exe";
       process.StartInfo.Arguments = "/c dir *.cs";
       process.StartInfo.UseShellExecute = false;
       process.StartInfo.RedirectStandardOutput = true;
       process.Start();
       string output = process.StandardOutput.ReadToEnd();
       Console.WriteLine("Output:");
       Console.WriteLine(output);
    }
}

using System;
using System.Diagnostics;
class Test
{
    static void ProcessDone(object sender, EventArgs e)
    {
       Console.WriteLine("Process Exited");
    }
    public static void Main()
    {
       Process process = new Process();
       process.StartInfo.FileName = "notepad.exe";
       process.StartInfo.Arguments = "process3.cs";
       process.EnableRaisingEvents = true;
       process.Exited += ProcessDone;
       process.Start();
       process.WaitForExit();
       Console.WriteLine("Back from WaitForExit()");
    }
}

Serialization

Serialization is the process used by the runtime to persist objects in some sort of storage or to transfer them from one location to another.

The metadata information on an object contains sufficient information for the runtime to serialize the fields, but the runtime needs a little help to do the right thing.

This help is provided through two attributes. The [Serializable] attribute is used to mark an object as OK to serialize. The [NonSerialized] attribute can be applied to a field or property to indicate that it shouldn’t be serialized. This is useful if it is a cache or derived value.

The following example has a container class named MyRow that has elements of the MyElement class. The cacheValue field in MyElement is marked with the [NonSerialized] attribute to prevent it from being serialized.

In this example, the MyRow object is serialized and deserialized to a binary format:

using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
[Serializable]
public class MyElement
{
    public MyElement(string name)
    {
       m_name = name;
       m_cacheValue = 15;
    }
    public override string ToString()
    {
       return String.Format("{0}: {1}", m_name, m_cacheValue);
    }
    string m_name;
    // this field isn't persisted.
    [NonSerialized]
    int m_cacheValue;
}
[Serializable]
public class MyRow
{
    public void Add(MyElement myElement)
    {
       m_elements.Add(myElement);
    }
    public override string ToString()
    {
       return String.Join(
            "
",
            m_elements
                .Select(element => element.ToString())
                .ToList());
    }
    List <MyElement> m_elements = new List <MyElement> ();
}
public class SerializationTest
{
    public static void Main()
    {
       MyRow row = new MyRow();
       row.Add(new MyElement("Gumby"));
       row.Add(new MyElement("Pokey"));
       Console.WriteLine("Initial value");
       Console.WriteLine("{0}", row);
       // write to binary, read it back
       using (Stream streamWriter = File.Create("MyRow.bin"))
       {
            BinaryFormatter binaryWriter = new BinaryFormatter();
            binaryWriter.Serialize(streamWriter, row);
       }
       MyRow rowBinary = null;
       using (Stream streamReader = File.OpenRead("MyRow.bin"))
       {
            BinaryFormatter binaryReader = new BinaryFormatter();
            rowBinary = (MyRow)binaryReader.Deserialize(streamReader);
       }
       Console.WriteLine("Values after binary serialization");
       Console.WriteLine("{0}", rowBinary);
    }
}

The example produces the following output:

Initial value
Gumby: 15
Pokey: 15
Values after binary serialization
Gumby: 0
Pokey: 0

The field cacheValue is not preserved since it was marked as [NonSerialized]. The file MyRow.Bin will contain the binary serialization. To serialize to XML, use the XmlSerializer class.

Custom Serialization

If the standard serialization doesn’t do exactly what is desired or doesn’t give sufficient control, a class can define exactly how it wants to be serialized,⁴ like in this example:

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
[Serializable]
class Employee : ISerializable
{
    int m_id;
    string m_name;
    string m_address;
    public Employee(int id, string name, string address)
    {
       m_id = id;
       m_name = name;
       m_address = address;
    }
    public override string ToString()
    {
       return (String.Format("{0} {1} {2}", m_id, m_name, m_address));
    }
    Employee(SerializationInfo info, StreamingContext content)
    {
       m_id = info.GetInt32("id");
       m_name = info.GetString("name");
       m_address = info.GetString("address");
    }
    // called to save the object data...
    public void GetObjectData(SerializationInfo info, StreamingContext content)
    {
       info.AddValue("id", m_id);
       info.AddValue("name", m_name);
       info.AddValue("address", m_address);
    }
}
class CustomSerializationTest
{
    public static void Serialize(Employee employee, string filename)
    {
       using (Stream streamWrite = File.Create(filename))
       {
            IFormatter writer = new BinaryFormatter();
            writer.Serialize(streamWrite, employee);
       }
    }
    public static Employee Deserialize(string filename)
    {
       Employee employee = null;
       using (Stream streamRead = File.OpenRead(filename))
       {
            IFormatter reader = new BinaryFormatter();
            employee = (Employee)reader.Deserialize(streamRead);
       }
       return (employee);
    }
    public static void Main()
    {
       Employee employee = new Employee(15, "Fred", "Bedrock");
       Serialize(employee, "emp.dat");
       Employee employeeBack = Deserialize("emp.dat");
       Console.WriteLine("Employee: {0}", employeeBack);
    }
}

To perform custom serialization, an object must implement the ISerializable interface. The GetObjectData() method is the only method on that interface. The implementation of that method stores each value by calling AddValue() on each value and passing in a name for the field and the field value.

To deserialize an object, the runtime relies on a special constructor. This constructor will call the appropriate get function to fetch a value based on the name.

Although this approach does take some extra space to store the names—and a bit of time to look them up—it versions very well, allowing new values to be added without invalidating existing stored files.

XML Serialization

The XmlSerializer class can be used to serialize an object to an XML representation. Here’s an example:

public class Employee
{
    public string Name { get; set; }
    public Decimal Salary { get; set; }
    public DateTime DateOfBirth { get; set; }
}
public static void SaveEmployee()
{
    Employee employee = new Employee();
    employee.Name = "Peter";
    employee.Salary = 15123M;
    employee.DateOfBirth = DateTime.Parse("12/31/1994");
    XmlSerializer serializer = new XmlSerializer(typeof(Employee));
    using (Stream writeStream = File.OpenWrite("Employee.xml"))
    {
       serializer.Serialize(writeStream, employee);
    }
}

This code will generate the following output:

<?xml version="1.0"?> 
  <Employee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" > 
  <Name> Peter</Name> 
  <Salary> 15123</Salary> 
  <DateOfBirth> 1994-12-31T00:00:00</DateOfBirth> 
</Employee>

Reading the object back in is equally simple.

public static Employee LoadEmployee()
{
    XmlSerializer serializer = new XmlSerializer(typeof(Employee));
    using (Stream readStream = File.OpenRead("Employee.xml"))
    {
       return (Employee) serializer.Deserialize(readStream);
    }
}

The XmlSerializer class provides a considerable amount of control over the format of the XML representation. Here’s an example:

[XmlType(TypeName = "Employee2005")]
public class Employee
{
    [XmlElement("FullName")]
    public string Name { get; set; }
    [XmlAttribute("Salary")]
    public Decimal Salary { get; set; }
    public DateTime DateOfBirth { get; set; }
    [XmlIgnore]
    public int Weight { get; set; }
}

The attributes have the following effects:

• The XmlType attribute changes the name of the Employee element to Employee2005.
• The XmlElement attribute changes the name of the Name property to FullName.
• The XmlAttribute attribute saves the salary as an attribute instead of an element.
• The XmlIgnore attribute skips the weight value during serialization.

Here is the generated XML:

<?xml version="1.0"? > 
  <Employee2005 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:xsd="http://www.w3.org/2001/XMLSchema" Salary="15123"> 
  <FullName> Peter</FullName> 
  <DateOfBirth> 1994-12-31T00:00:00</DateOfBirth> 
</Employee2005>

Reading Web Pages

The following example demonstrates how to fetch a web page using C#⁵:

using System;
using System.Net;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
static class PageFetcher
{
    public static string Fetch(string url)
    {
       WebRequest req = WebRequest.Create(new Uri(url));
       WebResponse resp = req.GetResponse();
       string contents = null;
       using (Stream stream = resp.GetResponseStream())
       using (StreamReader reader = new StreamReader(stream))
       {
            contents = reader.ReadToEnd();
       }
       return (contents);
    }
}
class WebPageTest
{
    public static void Main()
    {
       string page = PageFetcher.Fetch("http://www.microsoft.com");
       Console.WriteLine(page);
    }
}

Accessing Environment Settings

The System.Environment class can be used to obtain information about the machine and environment, as the following example demonstrates:

using System;
using System.Collections;
class EnvironmentTest
{
    public static void Main()
    {
       Console.WriteLine("Command Line: {0}", Environment.CommandLine);
       Console.WriteLine("Current Directory: {0}", Environment.CurrentDirectory);
       Console.WriteLine("Machine Name: {0}", Environment.MachineName);
       Console.WriteLine("Environment Variables");
       foreach (DictionaryEntry var in Environment.GetEnvironmentVariables())
       {
            Console.WriteLine("    {0}={1}", var.Key, var.Value);
       }
    }
}

¹ Actually, pretty much everything uses IEEE 754.

² Identical means “has exactly the same bit pattern.”

³ At this point, you may be asking, “Why do I read and write text files using the StreamWriter class? Why don’t I use the TextWriter class?” Many people have asked that question, and the answer is that it’s just one of the few unfortunate naming choices in the framework.

⁴ If you’re familiar with how MFC serialization worked in Visual C++, this approach will seem fairly familiar.

⁵ See Chapter 35 for more information on this subject.