Arrays are the most popular kind of collection. However, the .NET FCL offers a variety of other collections with different semantics. Collections are abstractions of data algorithms. ArrayList abstracts a dynamic array; the Stack collection abstracts a stack data structure; the Queue collection abstracts queues; the Hashtable collection abstracts a lookup table; and so on. Each collection exposes both unique and standard interfaces. The unique interface is specific to the collection type. For example, the Stack type has pop and push methods, whereas the Queue type has Dequeue and Enqueue methods. In addition, collections implement the ICollection, IEnumerable, and ICloneable interfaces. (These interfaces were described earlier in this chapter in separate sections specific to each interface.) The non-generic collection classes are implemented in the System.Collections namespace. For similar solutions to arrays, lists, and dictionaries, generic collections are preferred to non-generic and are implemented in System.Collections.Generic. Generics are detailed in Chapter 7.
Table 5-5 lists the non-generic collections in the .NET FCL.
What follows is a detailed explanation of each collection found in the Collections namespace. The explanations are complemented with sample code that highlights the uniqueness and strength of each collection. In addition to the listed member functions, many of the collections also support these extension methods: Queryable.AsQueryable, Enumerable.Cast, and Enumerable.OfType. These extension methods are explained in Chapter 7.
An array list is a dynamic array. While a conventional array has a fixed number of elements, elements can be added or deleted at run time with a dynamic array. ArrayList elements are accessible using the indexing operator and indices.
In addition to the standard collection interfaces, ArrayList also implements the IList interface.
Table 5-6 lists the ArrayList-specific methods and properties. The static members of ArrayList are thread-safe, whereas instance members are not.
Table 5-6. ArrayList members
The following code uses some ArrayList methods and properties. It creates a new ArrayList. Elements then are added from command-line arguments. The command-line arguments should be integer values. Then the values of the elements in the cloned ArrayList are doubled. Afterward, the cloned ArrayList is enumerated and every element is displayed:
using System;
using System.Collections;
namespace Donis.CSharpBook {
public class Starter {
public static void Main(string [] argv) {
ArrayList al1 = new ArrayList();
foreach(string arg in argv) {
al1.Add(int.Parse(arg));
}
al1.Sort();
ArrayList al2 = (ArrayList)al1.Clone();
for (int count = 0; count < al2.Count; ++count) {
al2[count] = ((int)al2[count]) * 2;
}
foreach (int number in al2) {
Console.WriteLine(number);
}
}
}
}The BitArray collection is a composite of bit values. Bit values are 1 and 0, where 1 is true and 0 is false. This collection provides an efficient means of storing and retrieving bit values.
Table 5-7 lists the methods and properties specific to a BitArray collection. The static members of the BitArray are thread-safe, whereas instance members are not.
Table 5-7. BitArray members
The following code demonstrates the BitArray collection. The Employee class contains a BitArray collection that tracks employee enrollment in various programs, such as the health plan and the credit union. This is convenient because program enrollment is always either true or false. In the Employee class, properties are provided to set and get enrollment in various programs:
using System;
using System.Collections;
namespace Donis.CSharpBook {
public class Starter {
public static void Main() {
Employee ben = new Employee();
ben.InProfitSharing = false;
ben.InHealthPlan = false;
Employee valerie = new Employee();
valerie.InProfitSharing = false;
Participation("Ben", ben);
Participation("Valerie", valerie);
}
public static void Participation(string name, Employee person) {
Console.WriteLine(name + ":");
if (person.InProfitSharing) {
Console.WriteLine(" Participating in" +
" Profit Sharing");
}
if (person.InHealthPlan) {
Console.WriteLine(" Participating in" +
" Health Plan");
}
if (person.InCreditUnion) {
Console.WriteLine(" Participating in" +
" Credit Union");
}
}
}
public class Employee {
public Employee() {
eflags.SetAll(true);
}
private BitArray eflags = new BitArray(3);
public bool InProfitSharing {
set {
eflags.Set(0, value);
}
get {
return eflags.Get(0);
}
}
public bool InHealthPlan {
set {
eflags.Set(1, value);
}
get {
return eflags.Get(1);
}
}
public bool InCreditUnion {
set {
eflags.Set(2, value);
}
get {
return eflags.Get(2);
}
}
}
}The Hashtable collection is a collection of key/value pairs. Entries in this collection are instances of the DictionaryEntry type. DictionaryEntry types have a Key and Value property to get and set keys and values.
In addition to the standard collection interfaces, the Hashtable collection implements the IDictionary, ISerializable, and IDeserializationCallback interfaces.
The entries are stored and retrieved in order based on the hash code contained in the key.
Table 5-8 lists the members of the Hashtable collection.
Table 5-8. Hashtable members
Hashtable.GetEnumerator implements IDictionary.GetEnumerator, which returns an IDictionaryEnumerator. IDictionaryEnumerator implements the IEnumerator interface, while also adding three properties: Entry, Key, and Value.
The following code extends the previous sample code for the BitArray collection. The program creates a Hashtable, where each element is an employee. The key is the employee ID, and the value is an instance of an Employee type:
using System;
using System.Collections;
namespace Donis.CSharpBook {
public class Starter {
public static void Main() {
Hashtable employees = new Hashtable();
employees.Add("A100", new Employee(
"Ben", true, false, true));
employees.Add("V100", new Employee(
"Valerie", false, false, true));
Participation((Employee) employees["A100"]);
Participation((Employee) employees["V100"]);
}
public static void Participation(Employee person) {
Console.WriteLine(person.Name + ":");
if (person.InProfitSharing) {
Console.WriteLine(" Participating in" +
" Profit Sharing");
}
if (person.InHealthPlan) {
Console.WriteLine(" Participating in" +
" Health Plan");
}
if (person.InCreditUnion) {
Console.WriteLine(" Participating in" +
" Credit Union");
}
}
}
public class Employee {
public Employee(string emplName) {
propName = emplName;
eflags.SetAll(true);
}
public Employee(string emplName,
bool profitSharing,
bool healthPlan,
bool creditUnion) {
propName = emplName;
InProfitSharing = profitSharing;
InHealthPlan = healthPlan;
InCreditUnion = creditUnion;
}
private BitArray eflags = new BitArray(3);
public bool InProfitSharing {
set {
eflags.Set(0, value);
}
get {
return eflags.Get(0);
}
}
public bool InHealthPlan {
set {
eflags.Set(1, value);
}
get {
return eflags.Get(1);
}
}
public bool InCreditUnion {
set {
eflags.Set(2, value);
}
get {
return eflags.Get(2);
}
}
private string propName;
public string Name {
get {
return propName;
}
}
}
}This is sample code that shows the use of an IDictionaryEnumerator enumerator:
using System;
using System.Collections;
namespace Donis.CSharpBook {
public class Starter {
public static void Main() {
Hashtable zHash = new Hashtable();
zHash.Add("one", 1);
zHash.Add("two", 2);
zHash.Add("three", 3);
zHash.Add("four", 4);
IDictionaryEnumerator e =
zHash.GetEnumerator();
while (e.MoveNext()) {
Console.WriteLine(
"{0} {1}",
e.Key, e.Value);
}
}
}
}A Queue collection abstracts a FIFO data structure. Queue collections are ideal for implementing messaging components.
Table 5-9 lists the members of the Queue collection.
Table 5-9. Queue members
This is sample code of the Queue collection. Customers are added to the queue and then displayed:
using System;
using System.Collections;
namespace Donis.CSharpBook {
public class Starter {
public static void Main() {
Queue waiting = new Queue();
waiting.Enqueue(new Customer("Bob"));
waiting.Enqueue(new Customer("Ted"));
waiting.Enqueue(new Customer("Kim"));
waiting.Enqueue(new Customer("Sam"));
while (waiting.Count != 0) {
Customer cust =
(Customer) waiting.Dequeue();
Console.WriteLine(cust.Name);
}
}
public class Customer {
public Customer(string cName) {
propName = cName;
}
private string propName;
public string Name {
get {
return propName;
}
}
}
}
}The SortedList collection is a combination of key/value entries and an ArrayList collection, where the collection is sorted by the key. Elements of the collection are accessible either through the key or through an index.
Table 5-10 includes the members of the SortedList collection.
Table 5-10. SortedList members
The following program is an application that tracks auto repair tickets. Each ticket, which is an instance of the AutoRepairTicket class, is added to a sorted list. The key is the customer name. The value is the actual ticket. After populating the SortedList type, the CustomerReport method lists the open tickets:
using System;
using System.Collections;
namespace Donis.CSharpBook {
public class Starter {
public static void Main() {
SortedList tickets = new SortedList();
AutoRepairTicket ticket = NewTicket("Ben");
tickets.Add(ticket.Name, ticket);
ticket = NewTicket("Donis");
tickets.Add(ticket.Name, ticket);
ticket = NewTicket("Adam");
tickets.Add(ticket.Name, ticket);
CustomerReport(tickets);
}
public static AutoRepairTicket NewTicket(
string customerName) {
return new AutoRepairTicket(customerName,
DateTime.Now);
}
public static void CustomerReport(SortedList list) {
foreach (DictionaryEntry entry in list) {
int nextTag = ((AutoRepairTicket) entry.Value).Tag;
string nextTime = ((AutoRepairTicket)
entry.Value).Time.ToShortTimeString();
Console.WriteLine("Customer: {0} Ticket: {1} Time: {2}",
entry.Key, nextTag, nextTime);
}
}
}
public class AutoRepairTicket{
public AutoRepairTicket(string customerName,
DateTime ticketTime) {
propName = customerName;
propTime = ticketTime;
propTag = ++count;
}
private string propName;
public string Name {
get {
return propName;
}
}
private DateTime propTime;
public DateTime Time {
get {
return propTime;
}
}
private int propTag;
public int Tag {
get {
return propTag;
}
}
private static int count = 1000;
}
}A Stack collection abstracts a LIFO data structure.
Table 5-11 lists the members of the Stack collection.
Table 5-11. Stack members
The following code adds numbers to a Stack collection. The values of the elements in the collection are removed from the stack and then displayed to the Console window:
using System;
using System.Collections;
namespace Donis.CSharpBook {
public class Starter {
public static void Main() {
Stack numbers = new Stack(
new int[] {1,2,3,4,5,6});
int total = numbers.Count;
for (int count = 0; count < total; ++count) {
Console.WriteLine(numbers.Pop());
}
}
}
}In addition to the common collections that most developers use, the .NET FCL offers specialized collections. These collections are found in the System.Collections.Specialized namespace. Although these collections are used infrequently, they are valuable in certain circumstances.
Table 5-12 lists the specialized collections.
Table 5-12. Specialized collections in the .NET FCL
Member | Description |
|---|---|
BitVector32 | This is an array of 32 bits. It is similar to a BitArray, but it is limited to 32 bits. Because of this array’s refined use, BitVector32 structures are more efficient than a BitArray collection. |
HybridDictionary | This collection is a combination of a ListDictionary and a Hashtable. It operates as a ListDictionary when it contains a small number of elements. For optimum performance, the collection switches to a Hashtable as the number of elements increases. |
NameValueCollection | This is a collection of keys and values, in which both the keys and values are strings. The collection is accessible via an index or key. A key can refer to multiple values. |
OrderedDictionary | This is a collection of key and value pairs, where each entry is accessible by either the key or the value. |
StringCollection | This is a collection of strings. |
StringDictionary | This is a combination of the Hashtable and StringCollection collections, in which both the keys and values are strings. |