Let’s say our Contact data structure is simply this:

public class Contact : IComparable
{
   // constructor omitted, just assume it assigns fields
 
   public string Forename { get; set; }
   public string Surname { get; set; }
   public string PhoneNo { get; set; }
   public string EmailAddress { get; set; }
 
   public int CompareTo(object obj) 
   {
        Contact otherContact = obj as Contact; 
        if (otherContact != null)
            return this.Surname.CompareTo(otherContact.Surname);
        else
           throw new ArgumentException("Object is not a Contact");
   }
}

In order to sort a collection of Contacts, we can simply call the Sort method as follows:

ArrayList list = new ArrayList();
// add some Contacts
list.Sort();

That’s all well and good, but we will always sort by Contact.Surname. The collection Sort method will automatically use the IComparable CompareTo method defined by each Contact element. If we want to sort by a different property, say PhoneNo, we must use an IComparer.

public class ContactPhoneNoComparer : IComparer
{
   public int Compare(object left, object right)
   {
      Contact first = left as Contact;
      Contact second = right as Contact;
      // null checking omitted for brevity
      return first.PhoneNo.CompareTo(second.PhoneNo);
   }
}

To sort the Contact collection by PhoneNo we can now do this:

ArrayList contacts = new ArrayList();
// add some Contacts
contacts.Sort(new ContactPhoneNoComparer());

At least we can centralise our comparison logic in comparer classes, but this .NET 1.1 way of doing things is a bit ugly. Since we are forced to use object, the compiler can’t do any type checking to save us from our own stupidity. We end up having to write boiler plate code to check our casts. These comparer classes are also a little verbose, especially if we need a lot of them.

What follows is shameless plagarism: when I read chapter 1 of C# in Depth I realised that it contained what would have been a good answer to my interview question. This is a diversion from the framework foundation, but a worthy one.

IComparer<T>

The casting, which is really the most significant limitation, can be removed by using IComparer<T>. Note that this is now much shorter and more readable.

public class ContactPhoneNoComparer : IComparer<Contact>
{
   public int Compare(Contact left, Contact right)
   {
      return left.PhoneNo.CompareTo(right.PhoneNo);
   }
}

Using a lambda expression

Using a lambda expression we can eliminate the IComparer entirely.

List<Contact> contacts = new List<Contact>();
// add some Contacts
contacts.Sort((l, r) => l.PhoneNo.CompareTo(r.PhoneNo));

Using the OrderBy extension method

Finally, using an extension method, we can do something even more readable. This time, the original order of the list is preserved, and we get a new contact list in the specified order.

List<Contact> contacts = new List<Contact>();
// add some Contacts
List<Contact> sortedContacts = contacts.OrderBy(c => c.PhoneNo);

IEnumerable & IEnumerator

The IEnumerable interface would perhaps have been better named IForwardIteratable, since it defines a scheme for forward only iteration. IEnumerable specifies a single method, GetEnumerator, which returns an IEnumerator, the actual forward iterator. IEnumerator specifies three members:

• Current property: the collection element to which the iterator is pointing.
• MoveNext method: moves the iterator to the next element in the collection. Returns false when the iterator has passed the final element.
• Reset method: set the iterator to the initial state, where calling MoveNext results in the iterator pointing at the first element.

You may then traverse a collection as follows:

IEnumerator enumerator = collection.GetEnumerator();
while (enumerator.MoveNext())
{
   Console.WriteLine(enumerator.Current.ToString());
}

foreach

The code snippet above might seem a little cumbersome. To improve matters both VB and C# provide the foreach language level construct. Using foreach the example above becomes simply:

foreach (object element in collection)
{
   Console.WriteLine(element.ToString());
}

Notice that this scheme is based on object rather than the derived type in the collection. So, if you don’t use generic collections, there might be an implicit cast from IEnumerator.Current to the target type.

• IEnumerable simply provides a method to return an IEnumerator. IEnumerator provides the mechanism for forward only iteration.
• ICollection extends IEnumerable adding some basic machinery for thread safe access and a Count property. Note that ICollection does not provide any way of adding/removing elements.
• IList extends ICollection to support indexing and the facility to add and remove elements. ILists can be fixed size and/or read only.
• IDictionary extends ICollection to support key value pairs. Values may be added, retrieved and removed by key. Both the keys and the values can be retreived as ICollections. IDictionarys can be fixed size and/or read only.

ArrayList : IList

ArrayList provides an IList interface over an array which is dynamically resized as you insert elements. Iterating over an ArrayList returns items in the order they were inserted (unless it has been sorted).

The following snippet demonstrates adding, inserting and removing elements and ranges of elements.

ArrayList al = new ArrayList();
al.Add("this");
 
// Add range requires an ICollection arg
string [] strs = { "is", "a", "list" };
al.AddRange(strs);
 
al.Insert(0, "hello");
 
string[] more = { "non", "sense" };
al.InsertRange(1, more);
 
al.RemoveAt(0);
al.RemoveRange(1, 2);

Note that runtime performance is similar to what you might expect if manipulating a raw array. For example, in the worst case, InsertRange is an O(m + n) operation, where n is the number of elements to be added and m is the number of elements in the ArrayList.

Casting and boxing

System.Collections classes come from a time before .NET generics. As a consequence, collection elements are objects – everything is cast to/from object as it is stored/retrieved. Value types also get boxed/uboxed. This is all additional overhead.

Contary to what it says in the Framework Foundation book, generics are *sometimes* faster because they avoid this casting and boxing (depending on your use case). Rico Mariani has an interesting performance comparison (the real killer is the repeated allocation of the ArrayList Enumerator).

ASCII, ISO and Unicode

The venerable ASCII encoding standard is the basis for modern character encoding. ASCII encodes non printable control characters, as well as a modern latin alphabet, digits, punctuation marks, and a few miscellaneous symbols. These values are encoded in 7-bits (0-127). ASCII does not standardise use of values 128 to 255 in 8-bits; different regions invented their own standards and this makes it difficult to exchange text encoded using potentially different standards across regions.

ANSI went some way toward solving this by defining standardised code pages consisting of both the standard ASCII values (0-127) and language specific values (128-255). For example, ISO 8859-1 is intended for western european languages. Clearly, ISO 8859 encodings are still not truly interoperable, but at least you know which characters are represented between 128-255.

Unicode was introduced almost twenty years ago to provide a world text encoding scheme, capable of encoding the characters used in every living language. Although initially restricted to 16-bits, there are now multiple Unicode encoding schemes.

System.Text Encodings

• UTF32Encoding is a UTF-32 encoding representing each code point as a 32-bit integer.
• UnicodeEncoding is a UTF-16 encoding representing each code point as a sequence of one to two 16-bit integers.
• UTF8Encoding is a UTF-8 encoding representing each code point as a sequence of one to four bytes.
• UTF7Encoding is a UTF-7 encoding representing Unicode characters as sequences of 7-bit ASCII characters.
• ASCIIEncoding corresponds to the Windows code page 20127. ASCII characters are limited to the lowest 128 Unicode characters, from U+0000 to U+007F.
• ANSI/ISO encodings can be accessed via the Encoding.GetEncoding method. This page gives a list of the supported encodings.

I was struck by the inconsistent naming of these classes, and that they don’t follow Microsoft’s naming conventions for capitalisation.

A simple example

Using Encoding.GetEncoding we can retrieve a Western European codepage, then get some encoded bytes using the GetBytes method. This is only slightly more typing than using one of the standard encoding classes described above.

byte[] westernEuroBytes = Encoding.GetEncoding("Windows-1252").GetBytes("foo bar");
byte[] utf16Bytes = Encoding.Unicode.GetBytes("foo bar");

Enumerating supported code pages

You can enumerate the available encodings as follows, this essentially reproduces the table found here.

foreach (EncodingInfo ei in Encoding.GetEncodings())
{
    Console.WriteLine("{0}, {1}, {2}", ei.CodePage, ei.Name, ei.DisplayName);
}

Encoding & File I/O

If you use an encoding other than UTF7, you must explicitly declare it when reading from the file, as follows.

using (StreamWriter sw = new StreamWriter("filename.txt", false, Encoding.Unicode))
{
    sw.WriteLine("foo bar");
}
 
using (StreamReader sw = new StreamReader("filename.txt", Encoding.Unicode))
{
    string line = sw.ReadLine();
}

If you encode the file using ASCII, you can decode it using ASCII, UTF-7 and UTF-8 encodings. UTF-16 and UTF-32 use larger bytes, and are therefore incompatible.

For a more detailed treatment, please refer to this site, which is worth visiting just to see the photograph of the author. If that’s too long winded, try the cheat sheet instead.

Regex: A Simple Example

Whilst the concept is simple, RegEx syntax is not. RegEx’s can be hard to read. This expression matches a UK postcode:

^[A-Za-z]{1,2}[\d]{1,2}([A-Za-z])?\s?[\d][A-Za-z]{2}$

This example includes several key bits of RegEx syntax. The ^ and $ characters are anchors, and specify the beginning and end. Square brackets denote a character set to match, [A-Za-z] matches upper and lower case characters in the range A-Z. Curly braces denote the number of matches, so [A]{1,2} will match the character A once or twice. The ? matches the preceeding expression zero or once, so \s? matches a white space character zero or once.

In the context of .NET, the Regex class provides static methods to test a string for a match. Here is a simple but useless example:

if (RegEx.IsMatch("pattern", @"^[aenprt]{1,7}$"))
{
   // do something...
}

Options

RegEx methods and constructors, where appropriate, provide an override where RegexOptions may be specified (e.g. compiled, case sensitive etc.). Options may be combined using a bitwise OR. You can also specify options inline within the regex pattern, by enclosing characters which map to regex options within brackets. There are two forms:

• Grouping construct (?imnsx-imnsx:)
• Miscelleneous construct (?imnsx-imnsx)

Prefixing a set of options with the minus sign turns them off. All the options are turned off by default. Compiled and RightToLeft may only be applied to an expression as a whole.

Grouping & Backreferences

Round brackets specify a group, and when referring back to a group it is possible to apply alternation and repitition operators. A simple example might be to search for repeating sequences of numbers preceeded by a space:

(?<groupname>\s\d)\k<groupname>

The (?pattern) construct is used to denote the group, then \k is used to refer back to the group. If you don’t specify a name within angle brackets, you can refer to groups by number using \ln, where n is the group number.

Extracting matches

Using the static Regex.Match method you may extract matches from an input string. The sub pattern you wish to extract should be enclosed in parentheses.

string input = "Exception: error message";
Match m = Regex.Match(input, "Exception: (.*$)");
string match1 = m.Groups[1].Value;
 
CaptureCollection captures = m.Groups[1].Captures;
Capture c = captures[0];
Console.WriteLine(string.Format("group '{0}', capture '{1}', index {2}", match1, c.Value, c.Index));
// prints: group 'error message', capture 'error message', index 11

If there is a match, the Match.Success property = true. The Match.Groups array contains the matches, indexed starting at 1. If you name the groups (using angle brackets as described above), you can also index by name. Groups comprise of capture collections, and each capture contains the match along with index and length properties.

Replacing matches

Using the static Regex.Replace method you may replace matches within the input string. This simple example shows how to use named backreferences within the replacement pattern.

string output = Regex.Replace("alex peck", @"(?<forename>\S+) (?<surname>\S+)", "${surname}, ${forename}");
// output = "peck, alex"

The replacement expression ${surname} inserts the match captured by the group (?). We could also use the expression $n, where n is an integer, to insert groups by number.

Online resources

• regexlib – Regular Expression Library
• regexpal – Test regular expressions in a web page (based on java)
• Regulator and Regulazy are available here
• reanimator – animate your regex as an automaton
• .NET MSDN reference

MSDN states that most of the methods that modify an instance of this class return a reference to that same instance. Since a reference to the instance is returned, you can call a method or property on the reference. This can be convenient if you want to write a single statement that chains successive operations one after another.

Performance consideration: StringBuilder is only really advantageous when working with larger string operations, like concatenating tens of strings in a loop. This is due to the overhead of creating a StringBuilder vs a string – StringBuilder is obviously more complex. Rico Mariani provides similar advice.

IsolatedStorageFile

IsolatedStorageFile provides functionality to create files and folders in isolated storage. The first step is to create a store, which can be scoped as either Assembly/Machine or Assembly/User. If you use machine scope, then all users can access the data. So, user specific data should go in user scope, application data in machine scope.

IsolatedStorageFile machineStore = IsolatedStorageFile.GetMachineStoreForAssembly();
IsolatedStorageFile userStore = IsolatedStorageFile.GetUserStoreForAssembly();

Click once applications can also access an application scope.

Once you have created a store you can use instance methods to manipulate files and directories. Instance properties allow you to evaluate current and maximum size, scope, and the identities (Application, Assembly, Domain) used for scoping.

IsolatedStorageFileStream

The IsolatedStorageFileStream class derives from FileStream, see .NET streams for more details. Here is an example of writing within a directory:

using (IsolatedStorageFile userStore = IsolatedStorageFile.GetUserStoreForAssembly())
{
    userStore.CreateDirectory("testDir");
 
    using (IsolatedStorageFileStream userStream = new IsolatedStorageFileStream(@"testDir\user.set", FileMode.OpenOrCreate, userStore))
    {
        using (StreamWriter userWriter = new StreamWriter(userStream))
        {
            userWriter.WriteLine("user data");
        }
    }
}

It’s slightly annoying that there is no directory exists method, so testing this before creating a directory involves calling GetDirectoryNames then iterating over the string array it returns – I didn’t show this for brevity. Here is how to read it back:

using (IsolatedStorageFile userStore = IsolatedStorageFile.GetUserStoreForAssembly())
{
    using (IsolatedStorageFileStream userStream = new IsolatedStorageFileStream(@"testDir\user.set", FileMode.Open, userStore))
    {
        StreamReader userReader = new StreamReader(userStream);
        string data = userReader.ReadLine();
    }
}

Permissions

The IsolatedStoragePermission class defines access to isolated storage capabilities. If you use isolated storage it is best practice to add an IsolatedStoragePermission attribute.

[IsolatedStorageFilePermission(SecurityAction.Demand)]
public class Program
{ /* ... */ }

The Filter property allows you to specify which file(s) you are interested in watching. The NotifyFilter allows you to specify which events to watch for (created/modified/deleted etc.). You can also specify whether or not to IncludeSubdirectories. Using these properties correctly ensures that a manageable amount of file system events are raised (see below).

FileSystemWatcher events use three delegate types:

• Changed, Created, Deleted events use FileSystemEventHandler
• Renamed events use a RenamedEventHandler
• Error events use a ErrorEventHandler

You should minimise the work performed in these event handlers, otherwise you can impact the number of events you may handle.

There is also a synchronous WaitForChanged method which returns a structure containing changes.

Caveats

I would advise setting the error handler first, otherwise you can get silent failures when setting other properties.

Generally, it is not advisable to use FileSystemWatcher on network drives. If/when a network outage occurs the watcher ceases to function, a simple workaround is given here.

The underlying Win 32 ReadDirectoryChangesW function will fail with ERROR_INVALID_PARAMETER if the buffer length is greater than 64 KB and the application is monitoring a directory over a network. This is due to a packet size limitation with the underlying file sharing protocols.

Furthermore, there is no guarantee that you will recieve notification of every change under heavy load scenarios. This is compounded for network shares, since you have a smaller buffer size limitation. See this page for a detailed explanation.

StreamReader & StreamWriter

In the previous post, strings were read and written to streams as byte arrays based on an encoding. StreamReader and StreamWriter allow strings to be read and written to steams more conveniently. Of course, they are derived from TextReader/Writer.

StringReader & StringWriter
StringReader and StringWriter provide similar functionality for reading and writing to strings. The writer is based on an underlying StringBuilder.

BinaryReader & BinaryWriter

The BinaryReader and BinaryWriter classes are closely related and read/write binary data to streams. They do not inherit from the text abstract bases (since they are not text based). They also implement IDisposable.

Stream overview

Stream presents properties to determine whether a stream CanRead, CanWrite, CanSeek or CanTimeout. Streams that support seeking implement the Position and Length properties.

Stream presents virtual methods to sequentially read and write (Read, ReadByte, Write, WriteByte), as well as Flush, Seek, SetLength and Close.

FileStream

This example illustrates how to write and read to a file, using the static File class to create the required FileStreams.

const string path = @"C:\file.txt";
 
using (FileStream fs = File.Create(path)) 
{
    byte[] info = new UTF8Encoding(true).GetBytes("some text to write");
    fs.Write(info, 0, info.Length);
}
 
using (FileStream fs = File.Open(path, FileMode.Open, FileAccess.Read)) 
{
    byte[] b = new byte[1024];
    UTF8Encoding encoding = new UTF8Encoding(true);
    while (fs.Read(b, 0, b.Length) > 0) 
    {
        Console.WriteLine(encoding.GetString(b));
    }
}

MemoryStream

You could repeat the above example, but substitute the FileStream for a MemoryStream.

MemoryStream ms = new MemoryStream();

MemoryStream also provides the facility to write to another stream, like so:

MemoryStream ms = new MemoryStream();
// write some data to ms
FileStream fs = File.Create(@"C:\mem.txt");
ms.WriteTo(fs);
fs.Close();
ms.Close();

BufferedStream

In order to improve performance, BufferedStream adds a buffering layer to read and write operations on another stream. For example:

FileStream fs = File.Create(@"C:\buffered.txt");
BufferedStream bs = new BufferedStream(fs);
// write data to bs like any other stream

Compressed streams

The System.IO.Compression namespace provides the GZipStream and DeflateStream classes. Both use the same compression algorithm (which does not depend on any patents). GZipStream writes data with headers that allow the data to be decompressed with GZip, and therefore has a slightly larger footprint.

Compressed streams may be used in a similar fashion to buffering:

FileStream destination = new FileStream(@"C:\compressed.txt");
// when writing to gzipStream, we compress data then write it to the destination stream
GZipStream gzipStream = new GZipStream(destination, CompressionMode.Compress);
byte[] buffer = new byte[256];
// put some data in the buffer
gzipStream.Write(buffer);

Decompression is essentially the same, except you perform reads instead of writes.