• 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).

Types

For some time I didn’t fully appreciate the difference between reference and value types. The following table summarises the important characteristics:

* Local as in declared within a method. When allocating a class with a value type member, this member will be allocated on the heap.

Boxing and Unboxing

A boxing operation converts a value type to a reference type; unboxing converts a reference type to a value type. For example, converting an int to an object (boxing) causes a new int to be created on the heap, the object reference then refers to this copy. Clearly, this incurs some overhead.

Generics

Generics are paramaterised types and methods, and are superficially similar to C++ templates. The most common use of generics in the .NET framework are the collection classes introduced in .NET 2.0.

Constraints may be specified to restrict use of generic types and methods:

Attributes

Attributes are programmatic annotations (metadata) that may be queried by reflection. An item decorated with an attribute can be an assembly, class, constructor, delegate, enum, event, field, interface, method, portable executable file module, parameter, property, return value, struct, or another attribute. Attributes derive from System.Attribute.

The TypeForwardedTo attribute allows you to move a type from one assembly to another without having to recompile the application which uses the original assembly. This is succinctly illustrated here.

Partial Classes

Partial Classes facilitate splitting class definitions across files. I find this is useful when using code generation – you can re-generate an entire class file from a model without overwriting hand written code.

Exceptions

The training material recommends that you define your own exceptions which derive from System.ApplicationException. It is therefore possible to differentiate between exceptions thrown from application code and the .NET framework.

In reality, it is best practice to simply inherit from Exception, as ApplicationException didn’t add any value.

Either way, having distinct exception classes allows you to respond to different exceptions differently. Since it is possible to catch a derived exception by catching the base type, catch blocks should be ordered from most to least specific.

The finally block should be used to dispose of non memory resources, e.g. closing files or a SqlConnection.