ArrayLists

An ArrayList is an array that has a dynamic size, so it can grow as necessary. ArrayLists can be used to store any type, including built-in types and custom types defined as classes.

A useful feature of an ArrayList is that it can be expanded on demand, if necessary. C# does this by creating a new instance of an ArrayList for the new size and copying the current members of the smaller ArrayList to the new ArrayList.

Caution

Expanding an ArrayList on demand comes at a price. An ArrayList is a reference type, and when it is expanded by creating a new ArrayList, you must not count on the reference always being at the same address.

You can add members of an ArrayList using two methods: Add and Insert. You can remove members from an ArrayList by using the Remove, RemoveAt, or Clear method. These and other useful methods provided by an ArrayList are described in Table 3-3.

Table 3-3: Useful ArrayList Methods

Method	Description
Add	Adds a new member to the end of the array
Insert	Allows you to place the new member in the ArrayList at whatever location you choose
Remove	Removes the first occurrence of the parameter that you pass
RemoveAt	Removes a specific member at a specific location in the ArrayList
Clear	Removes all members of the ArrayList
Clone	Creates a shallow copy of the list
Equals	Determines if two objects are equal
Reverse	Reverses the order of the array
ToArray	Copies the members to a new array
ToString	Returns a string that represents the current object

The ArrayList also provides a field called count, which will tell you how many members are in the ArrayList at a given time.

To iterate through an ArrayList, you can use any of the iterator statements defined in Chapter 4. The foreach or for statements are recommended, because they will define your intent more clearly than the other iterator statements.

The following example demonstrates declaring an instance of an ArrayList that will contain an initial ten members. This example uses a foreach loop. Notice the first operand of the foreach loop is of the type placed in the ArrayList, and the second operand is the name given to the instance of the ArrayList.

Hashtables

Hashtables are a collection of associated keys and values that are organized based on the hash code of the key.

When an entry is added to the Hashtable, the entry is placed into a bucket based on the hash code of the key. Subsequent lookups of the key use the hash code of the key to search in only one particular bucket, thus substantially reducing the number of key comparisons required to find an entry.

The load factor of a Hashtable determines the maximum ratio of entries to buckets. Smaller load factors cause faster average lookup times, at the cost of increased memory consumption. The default load factor of 1.0 generally provides the best balance between speed and size. You can specify a different load factor when the Hashtable is instantiated.

As entries are added to a Hashtable, the actual load factor of the Hashtable increases. When the actual load factor reaches the default or specified load factor, the number of buckets in the Hashtable is automatically increased to the smallest prime number that is larger than twice the current number of Hashtable buckets.

To declare an a new Hashtable, you must call new with the number of entries that you expect, like this:

            Hashtable a = new Hashtable(10);

You can add entries to a Hashtable by calling the Add method and supplying the key as the first parameter, followed by the value in the second, as in these examples:

            a.Add(100, Arrays");
            a.Add(200, "Classes");

There are three types of exceptions that can be thrown when adding a new key to the Hashtable:

• If you pass a null key, you will throw an exception of ArgumentNullException.

• If you try to add an entry that already exists, an ArgumentException will be thrown.

• If the Hashtable is read-only or of fixed length, a NotSupportedException will be thrown.

Note

IDictionary is the underlying interface used to create Hashtables, DictionaryBase, and SortedList collections. This interface provides support for associated key/value pairs. It also allows for enumeration but does not imply a sorted collection. Some common methods supported by this interface are Add, Clear, Contains, GetEnumerator, and Remove.

Since each element of the Hashtable is a key/value pair, the element type is not the type of the key or the type of the value. Therefore, you must use a DictionaryEntry object as the type to iterate through the collection, as in this example:

            foreach(DictionaryEntry d in a)
            {
                  Console.WriteLine(d.Value);
            }

Finally, you can call the Remove and Clear methods to remove entries.

            a.Remove(100);
            a.Clear();

Note

The Hashtable is the only built-in collection that has some thread safety. Specifically, it supports multiple readers and a single writer.

The following example demonstrates the use of Hashtables.

Queues

A Queue represents a first-in, first-out (FIFO) collection of objects. Queues should be used when the sequence of objects with regard to their order of entry is important to maintain. Queue entries are entered in one end of the collection and removed from the other end.

Caution

Note that Queues are not thread-safe by default. Therefore, you must use the Synchronize method or lock keyword to ensure two threads do not access the same Queue simultaneously.

To create a new Queue, you must declare a new instance with the number of entries as the first parameter, like this:

            Queue a = new Queue(10);
              int x = 0;

You add entries to a Queue by using the Enqueue method and passing the item to be queued as the first parameter, as in this example:

            a.Enqueue(x);
            x++;
            a.Enqueue(x);

To iterate through a Queue, you can use a foreach statement. The first operand of the foreach loop is of the same type that was inserted into the queue with the Enqueue method. The second operand is the name of the Queue collection that was declared. Here is an example of using foreach to iterate through a Queue:

            foreach(int y in a)
              {
                   Console.WriteLine(y);
              }

To remove items from the Queue, call the Dequeue method. The oldest items are always removed from the Queue first.

            a.Dequeue();

If you want to clear the whole Queue at once, you can use the Clear method.

            a.Clear();

The following example demonstrates how to use Queues.