Chapter 6 - Collections and Generics

The content and code of this article is referenced from book Pro C#5.0 and the .NET 4.5 Framework by Apress. The intention of the writing is to review the konwledge and gain better understanding of the .net framework. 

 

When the .net platform was released, programmers frequently used the classes of the System.Collections namespace to store and interact with bits of data used within an application. In .net 2.0, the C# programming language was enhanced to support a feature termed generics; and with this change, a brand new namespace was introduced in the base class libraries: System.Collections.Generic. 

 

1. The motivation for Collection class

The most primitive container one could use to hold application data is undoubtly the array. C# array allow you to define a set of identically typed items of a fixed upper limit. 

        public static void Main (string[] args)
        {
            string[] myStrings = { "string1", "string2", "string3" };

            foreach (string s in myStrings) {
                Console.WriteLine (s);
            }

            Array.Sort (myStrings);  //sort array
            Array.Reverse (myStrings); //reverse array
        }

While basic arrays can be useful to manage small amount of fixed-size data, there are many other times where you require a more flexible data structure, such as dynamically growing and shinking container. .Net base class library ships with a number of namespace containing collection classes. And they are built to dynamically resize themselves on the fly as you insert or remove items. 

You'll notice that a collection class can belong to one of two broad categories: nongeneric collections, generic collections. On the one side, nongeneric collections are typically designed to operate on System.Object type and are , therefore, very loosely typed containers. In contrast, generic collections are much more type safe, given that you must specify "type of type" they contain upon creation . 

 

2. System.Collections Namespace

Any .net application built with .net 2.0 or higher should ignore the classes in System.Collections in favor of corresponding classes in System.Collections.Generic. However, it is still important to know the basics of the nongeneric collection class. 

Class	Meaning	Key Implement interfaces
ArrayList	Represents a dynamically sized collection of objects listed in sequenial order	IList, ICollection, IEnumerable ICloneable
BitArray	Manages a compact array of bit values, which are represented as Boolean	ICollection, IEnumerable ana ICloneable
Hashtable	Represent a collection of key/value pairs that are organized based on the hash code of the key	IDictionary ICollection, IEnumerable and ICloneable
Queue	Represents a standard first-in, first-out collection of objects.	ICollection, IEnumerable, and ICloneable
SortedList	Represents a collection of key/value pairs that are sorted by the keys and are accessible by key and by index	IDictionary, ICollection, IEnumerable, ICloneable
Stack	A last-in, first-out stack providing push and pop functionality	ICollection, IEnumerable, and ICloneable

 

Key interfaces supported by classes of System.Collections

Interface	Meaning
ICollection	Defines general characteristics for all nongeneric collection types
ICloneable	Allows the implementing object to return a copy of itself to the caller
IDictionary	Allows a nongeneric collection object to represent its contents using key/value paris
IEnumerable	returns an object implementing the IEnumerator interface
IEnumerator	enables foreach style iteration of collection items
IList	Provides behavior to add, remove, and index items in a sequential list of objects

 

2.1 Working with ArrayList

ArrayList, you can add or remove items on the fly and container automatically resize itself accordingly:

        public static void Main (string[] args)
        {
            ArrayList strArray = new ArrayList ();
            strArray.AddRange (new string[] {"First", "Second", "Third" });

            Console.WriteLine ("This collection has {0} items", strArray.Count);

            //add a new item and display current count
            strArray.Add("Fourth!");
            Console.WriteLine ("This collection has {0} items", strArray.Count);

            //display all items
            foreach (string s in strArray) {
                Console.WriteLine (s);
            }

        }

 

2.2 System.Collections.Specialized Namespace

System.Collection.Specialized namespace defines a number of specialied collection types. 

Type	Meaning
HybridDictionary	This class implements IDictionary by using a ListDictionary while the collection is small, and then swithing to a Hashtable when the collection gets large
ListDictionary	This class is useful when you need to manage a small number of items that can change overtime.
StringCollection	This class provides an optimal way to manage large collections of string data
BitVector32	This class provides a simple structure that stores boolean values and small integers in 32 bits of memory.

 

While these specialized types might be just what your projects require in some situation, I won't comment on their usage here. In many cases, you will likely find the System.Collections.Generic namespace provides classes with similar functionality and additional benefits. 

 

2.3 The problem of non-generic collection

The first issue is that using the System.Collections and System.Collection.Specialied classes can result in some poorly performing code, especially when you are manipulating numerical data. The CLR must perform a number of memory transfer operations when you store structures in any nongeneric collection class prototyped to operate on System.Object. 

Second issue is that most of the nongeneric collection classes are not type safe, they were deveoloped to operate on System.Objects, and they could therefore contain anything at all. 

 

2.4 The issue of performance

C# provides a simple mechanism, termed boxing, to store the data in a value type within a reference variable. 

        static void SimpleBoxOperation()
        {
            int myInt = 23;
            object boxInt = myInt; //boxing operation
        }

Boxing can be formally defined as the process of explicitly assigning a value type to a System.Object variable. When you box a value, the CLR allocates a new object on the heap and copies and the value type's value into that instance. What is returned to you is a reference to the newly allocated heap-based object.

The opposite operation is unboxing, the process of converting the value held in the project reference back into a corrsponding value type on the stack. The CLR first values if the receiving data type is equivalent to the boxed type, if so, it copies the vlaue back into a local stack-based variable. 

        static void SimpleBoxOperation()
        {
            int myInt = 23;
            object boxInt = myInt; //boxing operation

            int unboxInt = (int)boxInt; //unboxing 
        }

The InvalidCastException will be thrown if you're attempting to unbox the int into a long type. 

Boxing and unboxing are convenient from a programmer's viewpoint, but this simplified approach to stack/heap memory transfer comes with the baggages of performance issues. 

 

3. Generic Collection

When you use Generic collection, you rectify all of the previous issues, including boxing/unboxing and a lack of type safety. 

        public static void Main (string[] args)
        {
            List<int> ints = new List<int> ();
            ints.Add (10);
            ints.Add (9);
            ints.Add (8);

            foreach (int i in ints) {
                Console.WriteLine (i);
            }
        }

Generics provide better performance because they do not result in boxing or unboxing penalities when storing value types. Generics are type safe because they can contain only the type of type you specify. 

 

3.1 Specifying type parameters for generic classes/structures

When you create an instance of a generic class or structure, you specify the type parameter when you delcare the variable and when you invoke the constructor. 

List<Person> morePeople = new List<Person>();

You can read it as a list of person objects. After you specify the type parameter of a generic item, it cannot be changed. 

In previous chpater, we learned about a number of nongenerice interfaces, such as IComparable, IEnumerable and IEnumerator. And we have implmented those interface on class. 

public class Car : IComparable
    {
        public int CarID { get; set;} //auto property

        public Car ()
        {
        }

        public int CompareTo(object c)
        {
            Car newCar = c as Car; //cast object to car
            if (newCar != null) {
                if (this.CarID > newCar.CarID)
                    return 1;
                if (this.CarID < newCar.CarID)
                    return -1;
                else
                    return 0;
            } 
            else 
            {
                Console.WriteLine ("invalid car type");
            }
        }
    }

And because the interface is nongeneric, the object type is used to as parameter and we have to cast it to appropriate type before processing. Now assume you use the generic counterpart of this interface. 

    public class Car : IComparable<Car>
    {
        public int CarID { get; set;} //auto property

        public Car ()
        {
        }
        public int CompareTo(Car newCar)
        {
            if (this.CarID > newCar.CarID)
                return 1;
            if (this.CarID < newCar.CarID)
                return -1;
            else
                return 0;
        }
    }

Here, you do not need to check incoming parameter is a Car because it can only be a Car. If Someone were to pass in an incompatible data type, you would get a compile-time error. 

 

3.2 The System.Collections.Generic namespace

When you are building a .net application and need a way to manage in-memory data, the classes of system.collections.Generic will most likely fit the bill. 

Interface	Meaning
ICollection<T>	defines a general characteristics
IComparer<T>	Defines a way to compare to objects
IDictionary<T>	Allows a generic collection object to represent its contents using key/value pairs
IEnumerable<T>	Returns the IEnumerator<T> interface for a given object
IEnumerator<T>	Enables foreach-style iteration over a generic collection
IList<T>	Provides behavior to add, remove, and index items in a sequential list of objects
ISet<T>	provides the base interface for the abstract of sets

The System.Collections.Generic namespace also defines serveral classes that implement many of these key interfaces. 

Generic Class	Key interface	Meaning
Dictionary<TKey, TValue>	ICollection<T>, IDictionary<TKey, TValue>, IEnumerable<T>	This represent a generic collection of keys and vlaues
LinkedList<T>	ICollection<T>, IEnumerable<T>	This represents a doubly linked list
List<T>	ICollection<T>, IEnmerable<T>, IList<T>	This is a dynamically resizable sequential list of items
Queue<T>	ICollection, IEnumerable<T>	This is a generic implementation of first-in, first-out
SortedDictionary<TKey, TValue>	ICollection<T>, IDictionary<TKey, TValue>	This is a generic implementation of a sorted set of key/value pairs
SortedSet<T>	ICollection<T>, IEnumerable<T>, ISet<T>	This represents a collection of objects that is maintained in sorted order with no duplication
Stack<T>	ICollection, IEnumerable<T>	This is generic implementation of a last-in, first-out list

 

3.3 Collection initialization syntax

This language feature makes it possible to populate many container with items by using syntax similar to what you use to populate a basic array. 

　　　　　　  int[] ints = { 0, 1, 2, 3, 4 };
            List<int> listInts = new List<int> { 0, 2, 3, 5 };
            ArrayList mList = new ArrayList { 3, 4, 9 };

 

3.4 Working with the List<T> class

The List<T> class is bound to be your most frequently used type in the System.Collection.Generic because it allows you to resize the contents of the container dynamically. 

        public static void UseGenericList()
        {
            List<Person> people = new List<Person> ()
            {
                new Person{FirstName = "person1", LastName="test", Age= 20},
                new Person{FirstName = "person2", LastName="test", Age= 26},
                new Person{FirstName = "person3", LastName="test", Age= 23},
            };

            Console.WriteLine ("There are {0} People", people.Count);

            foreach (Person p in people) {
                Console.WriteLine (p.FirstName);
            }

            //insert new person
            people.Insert(2, new Person{FirstName="Person4", LastName="test", Age=40});
            Console.WriteLine ("There are {0} people", people.Count);

            //copy data to array
            Person[] arrayOfPeople = people.ToArray();
            for (int i = 0; i < arrayOfPeople.Length; i++) {
                Console.WriteLine (arrayOfPeople [i].FirstName);
            }

        }

Here, you use initialization syntax to pupulate List<T> with objects, as a shorthand notation for calling Add() multiple times. 

 

3.5 Working with Stack<T> class

The stack class represents a collection that maintains items using a last-in, first-out manner. As you might expect, Stack<T> defines members named Push() and Pop() to place items onto or remove items from the stack. 

        public static void UseGenericStack()
        {
            Stack<Person> stackOfPeople = new Stack<Person> ();

            stackOfPeople.Push (new Person{ FirstName = "person1", LastName = "test", Age = 10 });
            stackOfPeople.Push (new Person{ FirstName = "person2", LastName = "test", Age = 11 });
            stackOfPeople.Push (new Person{ FirstName = "person3", LastName = "test", Age = 13 });

            //look at the top item, pop it and look again
            Console.WriteLine("First person is {0}", stackOfPeople.Peek().FirstName);
            Console.WriteLine ("Popped off {0}", stackOfPeople.Pop ());

            Console.WriteLine("First person is {0}", stackOfPeople.Peek().FirstName);
            Console.WriteLine ("Popped off {0}", stackOfPeople.Pop ());

            Console.WriteLine("First person is {0}", stackOfPeople.Peek().FirstName);
            Console.WriteLine ("Popped off {0}", stackOfPeople.Pop ());

            try{
                Console.WriteLine("First person is {0}", stackOfPeople.Peek().FirstName);
                Console.WriteLine ("Popped off {0}", stackOfPeople.Pop ());
            }
            catch(InvalidOperationException ex) {
                Console.WriteLine (ex.Message);
            }
        }

 

3.6 Working with Queue<T> class

Queues are containers that ensure items are accessed in first-in, first-out manner. 

member of Queue<T>	Meaning
Dequeue()	Removes and returns the object at the beginning of the Queue<T>
Enqueue()	Adds an object to the end of the Queue<T>
Peek()	Returns the object at the beginning of the Queue<T> without removing it

        public static void UseGenericQueue()
        {
            Queue<Person> peopleQ = new Queue<Person> ();
            peopleQ.Enqueue (new Person{ FirstName = "test1", LastName = "test", Age = 13 });
            peopleQ.Enqueue (new Person{ FirstName = "test2", LastName = "test", Age = 13 });
            peopleQ.Enqueue (new Person{ FirstName = "test3", LastName = "test", Age = 13 });

            //peek at the first person
            Console.WriteLine("{0} is in the first position", peopleQ.Peek().FirstName);
            //remove the first person
            peopleQ.Dequeue ();
            Console.WriteLine("{0} is in the first position", peopleQ.Peek().FirstName);
        }

 

3.7 Working with SortedSet<T> class

The SortedSet<T> class is useful because it automatically ensures that the items in the set are sorted when you insert or remove items. However, you do need to inform it how you want to sort the objects, by passing in as a constructor argument an object that implements the generic IComparer<T> interface. 

 

        static void SortedSet()
        {
            SortedSet<Person> setOfPeople = new SortedSet<Person> (new SortByAge ()) {
                new Person{ FirstName = "test1", LastName = "test", Age = 20 },
                new Person{ FirstName = "test2", LastName = "test", Age = 34 },
                new Person{ FirstName = "test3", LastName = "test", Age = 40 }
            };

            foreach (Person p in setOfPeople) {
                Console.WriteLine (p.Age);
            }

            //add other people
            setOfPeople.Add(new Person{FirstName="test4", LastName="test", Age=5});
            setOfPeople.Add(new Person{FirstName="test4", LastName="test", Age=80});
            foreach (Person p in setOfPeople) {
                Console.WriteLine (p.Age);
            }

        }

As the result, the list is sorted by person's age. 

 

4. System.Collections.ObjectModel

Now, we can briefly examine an additional collection-centric namspace, System.Collections.ObjectModel. This is a relatively small namespace, which contains a handful of classes. 

System.Collections.ObjectModel Type	Meaning
ObservableCollection<T>	Represents a dynamic data collection that provides notifications when items get added, removed, or when the whole list is refreshed
ReadOnlyObservableCollection<T>	Represents a read-only version of ObservableCollection<T>

 

The observableCollection<T> class is very userful in that it has the ability to inform external objects when its contents have changed in some way. 

 

4.1 Working with ObservableCollection<T>

In many ways, working with the ObservableCollection<T> is identical to working with List<T>, given that both of these classes implement the same core interfaces. What makes it unique is that this class supports an event named CollectionChanged. This event will fire whenever a new item is inserted, a current item is removed. 

        public static void Main (string[] args)
        {
            ObservableCollection<Person> people = new ObservableCollection<Person> () {
                new Person{FirstName="test1", LastName ="test", Age=20},
                new Person{FirstName="test2", LastName ="test", Age=23},
            };
                
            people.CollectionChanged += (object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => {
                Console.WriteLine("Action for this event {0}", e.Action.ToString());
                switch(e.Action)
                {
                case NotifyCollectionChangedAction.Remove:
                    Console.WriteLine("Old items");
                    foreach(Person p in e.OldItems)
                    {
                        Console.WriteLine(p.FirstName);
                    }
                    break;
                case NotifyCollectionChangedAction.Add:
                    Console.WriteLine("New items");
                    foreach(Person p in e.NewItems)
                    {
                        Console.WriteLine(p.FirstName);
                    }
                    break;
                default:
                    break;
                }
            };

            //add one person
            people.Add (new Person{ FirstName = "test3", LastName = "test", Age = 32 });

        }

 

5. Create custom generic methods

While most developers typically use the existing generic types within the base class libraries, it is also possible to build your own generic members and custom generic types. When you build custom generic methods, you achieve a supercharnged version of traditional method overloading. While overloading is a useful feature in an object-oriented language, one problem is that you can easily end up with a ton of methods that essentially do the same thing.  

        static void Swap(ref int a, ref int b)
        {
            int temp;
            temp = a;
            a = b;
            b = temp;
        }

        static void Swap(ref Person a , ref Person b)
        {
            Person temp;
            temp = a;
            a = b;
            b = temp;
        }

        //one generic methods
        static void Swap<T>(ref T a, ref T b)
        {
            T temp;
            temp = a;
            a = b;
            b = temp;
        }

As you can see, we can write one generic mehtod, instead of creating two methods basically doing the same thing. 

 

 6. Create Custom Generic Structures and Classes

It's time to turn your attention to the construction of a gennric structure or class. 

    public struct Point<T>
    {
        private T xPos;
        private T yPos;

        public Point(T xValue, T yValue)
        {
            xPos = xValue;
            yPos = yValue;
        }

        public T X
        {
            get{ return xPos; }
            set{ xPos = value; }
        }

        public T Y
        {
            get { return yPos; }
            set { yPos = value; }
        }
    }

 

6.1 The default keyword in generic code

With the introduction of generic, the C# default keyword has been given a dual identity. In addition to its use within a swith construct, it can also be used to set a type parameter to its default value. This is helpful because generic type does not know the actual placeholders up front.  Numeric values have a default value of 0, reference types have a default value of null. 

    public void ResetValue()
        {
            xPos = default(T);
            yPos = default(T);
        }

 

6.2 Constraining type parameters

In this chapter, any generic item has at least one type parameter that you need to specify at the time you interact with the generic type or member. This alone allows you to build some type-safe code; however, the .net platform allows you to use the where keyword to get extremely specific about what a given type parameter must look like. 

Using this keyword, you can add a set of constraints to a given type parameter, which the C# compiler will check at the compile time. 

Generic	Meaning
Where T : struct	The type parameter <T> must have System.ValueType in its chain of inheritance (i.e <T> must be structure).
Where T : class	The type parameter <T> must not have System.ValueType in it chain of inheritance (i.e, <T> must be a reference type)
Where T : new()	The type parameter <T> must have a default constructor. Note that this constraint must be listed last on a multiconstrained type
where T : NameOfBaseClass	The type parameter <T> must be derived from the class specified by NameOfBaseClass
where T : NameOfInterface	The type parameter <T> must implement the interface specified by NameOfInterface. You can separate multiple interfaces as a comma delimited list

 

    public class MyGeneric<T> where T : new(){}

    public class MyGeneric1<T> where T : MainClass, IComparable, new(){}

    public class MyGeneric2<T, K> where T : new() where K : struct, IComparable<T>{}