Variables that contain single values are plenty useful. Even class structures that can describe compound objects made up of parts (such as a vehicle with its engine and transmission) are critical. But you also need a construct for holding a bunch of objects, such as Bill Gates' extensive collection of vintage cars or a certain author's vintage sock collection. The built-in class Array is a structure that can contain a series of elements of the same type (all int values and all double values, for example, or all Vehicle objects and Motor objects — you meet these latter sorts of objects in Chapter 7 of this minibook).

double d0 = 5;
double d1 = 2;
double d2 = 7;
double d3 = 3.5;
double d4 = 6.5;
double d5 = 8;

double sum = d0 + d1 + d2 + d3 + d4 + d5;
double average = sum / 6;

double[] doublesArray = {5, 2, 7, 3.5, 6.5, 8, 1, 9, 1, 3};

double[] doublesArray = new double[6];

doublesArray[0] // Corresponds to d0 (that is, 5)
doublesArray[1] // Corresponds to d1 (that is, 2)
. . .

// FixedArrayAverage -- Average a fixed array of numbers using a loop.
namespace FixedArrayAverage
{
  using System;
  public class Program
  {
    public static void Main(string[] args)
    {
      double[] doublesArray = {5, 2, 7, 3.5, 6.5, 8, 1, 9, 1, 3};
      // Accumulate the values in the array into the variable sum.
      double sum = 0;
      for (int i = 0; i < 10; i++)
      {
        sum = sum + doublesArray[i];
      }
      // Now calculate the average.
      double average = sum / 10;
      Console.WriteLine(average);
      Console.WriteLine("Press Enter to terminate...");
      Console.Read();
    }
  }
}

for(int i = 0; i < 11; i++)

IndexOutOfRangeException was unhandled
Index was outside the bounds of the
         array.

double[] doublesArrayVariable = new double[N];  // Variable, versus ...
double[] doublesArrayFixed = new double[10];    // Fixed

// VariableArrayAverage -- Average an array whose size is
//    determined by the user at runtime, accumulating the values
//    in an array. Allows them to be referenced as often as
//    desired. In this case, the array creates an attractive output.
namespace VariableArrayAverage
{
  using System;
  public class Program
  {
    public static void Main(string[] args)
    {
      // First read in the number of doubles the user intends to enter.
      Console.Write("Enter the number of values to average: ");
      string numElementsInput = Console.ReadLine();
      int numElements = Convert.ToInt32(numElementsInput);
      Console.WriteLine();
      // Now declare an array of that size.
      double[] doublesArray = new double[numElements]; // Here's the 'N'.
      // Accumulate the values into an array.
      for (int i = 0; i < numElements; i++)
      {
        // Prompt the user for another double.
        Console.Write("enter double #" + (i + 1) + ": ");
        string val = Console.ReadLine();
        double value = Convert.ToDouble(val);
        // Add this to the array using bracket notation.
        doublesArray[i] = value;
      }
      // Accumulate 'numElements' values from
      // the array in the variable sum.
      double sum = 0;
      for (int i = 0; i < numElements; i++)
      {
        sum = sum + doublesArray[i];
      }

      // Now calculate the average.
      double average = sum / numElements;
      // Output the results in an attractive format.
      Console.WriteLine();
      Console.Write(average + " is the average of (" + doublesArray[0]);
      for (int i = 1; i < numElements; i++)
      {
        Console.Write(" + " + doublesArray[i]);
      }
      Console.WriteLine(") / " + numElements);
      // Wait for user to acknowledge the results.
      Console.WriteLine("Press Enter to terminate...");
      Console.Read();
    }
  }
}

Enter the number of values to average:5

enter double #1: 1
enter double #2: 2
enter double #3: 3

enter double #4: 4
enter double #5: 5

3 is the average of (1 + 2 + 3 + 4 + 5) / 5
Press Enter to terminate...

// Now declare an array of that size.
double[] doublesArray = new double[numElements];
// Accumulate the values into an array.
for (int i = 0; i < numElements; i++)
{
  . . .
}

// Accumulate the values into an array.
for (int i = 0; i < doublesArray.Length; i++) ...

double[] fixedLengthArray = {5, 2, 7, 3.5, 6.5, 8, 1, 9, 1, 3};
double[] variableLengthArray = new double[10];

double[] fixedLengthArray = new double[10] {5, 2, 7, 3.5, 6.5, 8, 1, 9, 1, 3};

Given an array of strings, the following loop averages their lengths:

public class Student  // Read about classes in Book II.
{
  public string name;
  public double gpa;         // Grade point average
}
public class Program
{
  public static void Main(string[] args)
  {
    //  . . .create the array somehow . . .
    // Now average the students you have.
    double sum = 0.0;
    for (int i = 0; i < students.Length; i++)
    {
      sum += students[i].gpa;
    }
    double avg = sum / students.Length;
    //  . . .do something with the average . . .
  }
}

The for loop iterates through the members of the array. (Yes, you can have arrays of any sort of object, not just of simple types such as double and string. You most likely haven't been formally introduced to classes yet, so bear with me a bit longer. I get into them in the next book.)

students.Length contains the number of elements in the array.

// Now average the students that you have.
double sum = 0.0;
foreach (Student student in students)
{
  sum += student.gpa;  // This extracts the current student's GPA.
}
double avg = sum / students.Length;

The first time through the loop, foreach fetches the first Student object in the array and stores it in the variable student. On each subsequent pass, foreach retrieves the next element. Control passes out of the foreach loop when all elements in the array have been processed.

Notice that no index appears in the foreach statement. The lack of an index greatly reduces the chance of error and is simpler to write than the for statement, although sometimes that index is handy and you prefer a for loop.

A common programming challenge is the need to sort the elements within an array. Just because an array cannot grow or shrink doesn't mean that the elements within it cannot be moved, removed, or added. For example, the following code snippet swaps the location of two string elements within the array strings:

string temp = strings[i]; // Save the i'th string.
strings[i] = strings[k];  // Replace it with the kth.
strings[k] = temp;        // Replace kth with temp.

In this example, the object reference in the ith location in the strings array is saved so that it isn't lost when the second statement replaces it with another element. Finally, the temp variable is saved back into the kth location. Pictorially, this process looks like Figure 6-1.

Figure 6-1. The term swapping two objects means swapping references to two objects.

The following program demonstrates how to use the ability to manipulate elements within an array as part of a sort. This particular sorting algorithm is the bubble sort. Though it's not so great on large arrays with thousands of elements, it's simple and effective on small arrays:

// BubbleSortArray -- Given a list of planets, sort their
//    names: first, in alphabetical order.
//    Second, by the length of their names, shortest to longest.
//    Third, from longest to shortest.
//    This demonstrates using and sorting arrays, working with
//    them by array index. Two sort algorithms are used:
//    1. The Sort algorithm used by class Array's Sort() method.
//    2. The classic Bubble Sort algorithm.
using System;

namespace BubbleSortArray
{
  class Program
  {
    static void Main(string[] args)
    {
      Console.WriteLine("The 5 planets closest to the sun, in order: ");
      string[] planets =
        new string[] { "Mercury", "Venus", "Earth", "Mars", "Jupiter" };
      foreach (string planet in planets)
      {
        // Use the special char 	 to insert a tab in the printed line.
        Console.WriteLine("	" +  planet);
      }

Console.WriteLine("
Now listed alphabetically: ");
      // Array.Sort() is a method on the Array class.
      // Array.Sort() does its work in-place in the planets array,
      // which leaves you without a copy of the original array. The
      // solution is to copy the old array to a new one and sort it.
      string[] sortedNames = planets;
      Array.Sort(sortedNames);
      // This demonstrates that (a) sortedNames contains the same
      // strings as planets and (b) that they're now sorted.
      foreach (string planet in sortedNames)
      {
        Console.WriteLine("	" + planet);
      }

      Console.WriteLine("
List by name length - shortest first: ");
      // This algorithm is called "Bubble Sort": It's the simplest
      // but worst-performing sort. The Array.Sort() method is much
      // more efficient, but I couldn't use it directly to sort thex
      // planets in order of name length because it sorts strings,
      // not their lengths.
      int outer;  // Index of the outer loop
      int inner;  // Index of the inner loop
      // Loop DOWN from last index to first: planets[4] to planets[0].
      for (outer = planets.Length - 1; outer >= 0; outer--)
      {
        // On each outer loop, loop through all elements BEYOND the
        // current outer element. This loop goes up, from planets[1]
        // to planets[4]. Using the for loop, you can traverse the
        // array in either direction.
        for (inner = 1; inner <= outer; inner++)
        {
          // Compare adjacent elements. If the earlier one is longer
          // than the later one, swap them. This shows how you can
          // swap one array element with another when they're out of order.
          if (planets[inner - 1].Length > planets[inner].Length)
          {
            // Temporarily store one planet.
            string temp = planets[inner - 1];
            // Now overwrite that planet with the other one.
            planets[inner - 1] = planets[inner];
            // Finally, reclaim the planet stored in temp and put
            // it in place of the other.
            planets[inner] = temp;
          }
        }
      }
      foreach (string planet in planets)
      {
        Console.WriteLine("	" + planet);
      }

      Console.WriteLine("
Now listed longest first: ");
      // That is, just loop down through the sorted planets.
      for(int i = planets.Length - 1; i >= 0; i--)
      {
        Console.WriteLine("	" + planets[i]);
      }

      Console.WriteLine("
Press Enter to terminate...");
      Console.Read();
    }
  }
}

The program begins with an array containing the names of the first five planets closest to the sun. (To keep the figures small, I didn't include the outer planets, so I didn't have to decide about poor Pluto, which is, what now? — a planetoid or something?)

The program then invokes the array's own Sort() method. After sorting with the built-in Sort() method on the Array class, the program sorts the lengths of the planets' names using a custom sort just to amaze you.

The algorithm for the second sort works by continuously looping through the list of strings until the list is sorted. On each pass through the sortedNames array, the program compares each string to its neighbor. If the two are found to be out of order, the method swaps them and then flags the list as not sorted. Figures 6-2 through 6-5 show the planets list after each pass. In Figure 6-5, note that the next-to-last pass results in a sorted list and that the final pass terminates the sort because nothing changes.

Figure 6-2. Before starting the bubble sort.

Figure 6-3. After Pass 1 of the bubble sort.

Figure 6-4. After Prass 2 of the bubble sort.

Figure 6-5. The final pass terminates the sort because nothing changes.

Eventually, longer planet names "bubble" their way to the top of the list; hence the name bubble sort.

Traditionally, you used one of the following forms (which are as old as C# — almost six years old at the time this book was written) to initialize an array:

int[] numbers = new int[3];            // Size but no initializer, or ...
int[] numbers = new int[] { 1, 2, 3 }; // Initializer but no size, or ...
int[] numbers = new int[3] { 1, 2, 3 };// Size and initializer, or ...
int[] numbers = { 1, 2, 3 };           // No 'new' keyword -- extreme short form.

Chapter 2 of this minibook introduces the new var keyword, which tells the C# compiler, "You figure out the variable type from the initializer expression I'm providing."

Happily, var works with arrays, too:

// myArray is an int[] with 6 elements.
var myArray = new [] { 2, 3, 5, 7, 11, 13 };  // Initializer required!

The new syntax has only two changes:

Here are a few more examples:

var names = new [] { "John", "Paul", "George", "Ringo" };        // Strings
var averages = new [] { 3.0, 3.34, 4.0, 2.0, 1.8 };              // Doubles
var prez = new []{new President("FDR"), new President("JFK")};   // Presidents

var names = { "John", "Paul", "George", "Ringo" };  // Needs 'new []'

The var way is less concise, but when used in some other situations not involving arrays, it truly shines and in some cases is mandatory. (You can see examples in Chapter 7.)

Often an array is the simplest, most straightforward way to deal with a list of Students or a list of doubles. You also encounter many places in the .NET Framework class library that require the use of arrays.

But arrays have a couple of fairly serious limitations that sometimes get in your way. At such times, you'll appreciate the extensive C# repertoire of more flexible collection classes.

Although arrays have the advantage of simplicity and can have multiple dimensions, they suffer from two important limitations:

Most collections, on the other hand, make it much easier to add, insert, or remove elements, and you can resize them as needed, right in midstream. In fact, most collections usually take care of resizing automatically.

Arrays and collections have some characteristics in common:

In this section, I'll get you up and running with collection syntax and introduce the most important and most frequently used collection classes.

Table 6-1 lists the main collection classes in C#. I find it useful to think of collections as having various "shapes" — the list shape or dictionary shape, for example.

List<int> intList = new List<int>(); // Instantiating for int

Suppose you need to store a list of MP3 objects, each of which represents one item in your MP3 music collection. As an array, it might look like this:

MP3[] myMP3s = new MP3[50];         // Start with an empty array.
myPP3s[0] = new MP3("Norah Jones"); // Create an MP3 and add it to the array.
// ... and so on.

With a list collection, it looks like this:

List<MP3> myMP3s = new List<MP3>();   // An empty list
myMP3s.Add(new MP3("Avril Lavigne")); // Call the list's Add() method to add.
// ... and so on.

So what, you say? These examples look similar, and the list doesn't appear to provide any advantage over the array. But what happens when you add the 50th MP3 to the array and then want to add a 51st? You're out of room. Your only course is to declare a new, larger array and then copy all MP3s from the old array into the new one. Also, if you remove an MP3 from the array, your array is left with a gaping hole. What do you put into that empty slot to take the place of the MP3 you ditched? The value null, maybe?

The list collection sails happily on, in the face of those same obstacles. Want to add MP3 number 51? No problem. Want to junk your old Pat Boone MP3s? (Are there any?) No problem. The list takes care of healing itself after you delete old Pat.

The following code (excerpted from the example) shows how to instantiate a new, empty list for the string type. In other words, this list can hold only strings:

// List<T>: note angle brackets plus parentheses in
// List<T> declaration; T is a "type parameter",
// List<T> is a "parameterized type."
// Instantiate for string type.
List<string> nameList = new List<string>();
sList.Add("one");
sList.Add(3);                            // Compiler error here!
sList.Add(new Student("du Bois"));       // Compiler error here!

You add items to a List<T> by using its Add() method. The preceding code snippet successfully adds one string to the list, but then it runs into trouble trying to add first an integer and then a Student. The list was instantiated for strings, so the compiler rejects both attempts.

The next code fragment instantiates a completely new list for type int and then adds two int values to the list. Afterward, the foreach loop iterates the int list, printing out the ints:

// Instantiate for int.
List<int> intList = new List<int>();
intList.Add(3);                          // Fine.
intList.Add(4);
Console.WriteLine("Printing intList:");
foreach(int i in intList)  // foreach just works for all collections.
{
  Console.WriteLine("int i = " + i);
}

The following bit of code instantiates a new list to hold Students and adds two students with its Add() method. But then notice the array of Students, which I add to the student list using its AddRange() method. AddRange() lets you add a whole array or (almost) any other collection to the list, all at once:

// Instantiate for Student.
List<Student> studentList = new List<Student>();
Student student1 = new Student("Vigil");
Student student2 = new Student("Finch");
studentList.Add(student1);
studentList.Add(student2);
Student[] students = { new Student("Mox"), new Student("Fox") };
studentList.AddRange(students); // Add whole array to List.
Console.WriteLine("Num students in studentList = " + studentList.Count);

(Don't worry about the "new Student" stuff. I get to that topic in Book II.)

Student[] students = studentList.ToArray();  // studentList is a List<Student>.

List<T> also has a number of other methods for adding items, including methods to insert one or more items anywhere in the list and methods to remove items or clear the list. Note that List<T> also has a Count property. (This single nit can trip you up if you're used to the Length property on arrays and strings. For collections, it's Count.)

The next snippet demonstrates several ways to search a list: IndexOf() returns the array-style index of an item within the list, if found, or −1 if not found. The code also demonstrates accessing an item with array-style indexing and via the Contains() method. Other searching methods include BinarySearch(), not shown:

// Search with IndexOf().
Console.WriteLine("Student2 at " + studentList.IndexOf(student2));
string name = studentList[3].Name;  // Access list by index.
if(studentList.Contains(student1))  // student1 is a Student object.
{
  Console.WriteLine(student1.Name + " contained in list");
}

The final code segment demonstrates several more List<T> operations, including sorting, inserting, and removing items:

studentList.Sort(); // Assumes Student implements IComparable interface  (Ch 14).
studentList.Insert(3, new Student("Ross"));
studentList.RemoveAt(3);  // Deletes the third element.
Console.WriteLine("removed " + name);         // Name defined above

That's only a sampling of the List<T> methods. You can look up the full list in Help.

You've no doubt used Webster's or another dictionary. It's organized as a bunch of words in alphabetical order. Associated with each word is a body of information including pronunciations, definitions, and other information. To use a dictionary, you look up a word and retrieve its information.

In C#, the dictionary "shape" differs from the list shape. Dictionaries are represented by the Dictionary<TKey, TValue> class. TKey represents the data type used for the dictionary's keys (similar to the words in a standard dictionary or the terms you look up). TValue represents the data type used to store the information or data associated with a key (similar to the word's definitions in Webster's).

The first piece of the code just creates a new Dictionary object that has string keys and string values. You aren't limited to strings, though. Either the key or the value, or both, can be any type. Note that the Add() method requires both a key and a value.

Dictionary<string, string> dict = new Dictionary<string, string>();
//  Add(key, value).
dict.Add("C#", "cool");
dict.Add("C++", "like writing Sanskrit poetry in Morse code");
dict.Add("VB", "a simple but wordy language");
dict.Add("Java", "good, but not C#");
dict.Add("Fortran", "ANCNT");  // 6-letters-max variable name for "ancient."
dict.Add("Cobol", "even more wordy, or is it wordier, and verbose than VB");

The ContainsKey() method tells you whether the dictionary contains a particular key. There's a corresponding ContainsValue() method too:

// See if the dictionary contains a particular key.
Console.WriteLine("Contains key C# " + dict.ContainsKey("C#"));     // True
Console.WriteLine("Contains key Ruby " + dict.ContainsKey("Ruby")); // False

You can, of course, iterate the dictionary in a loop just as you can in any collection. But keep in mind that the dictionary is like a list of pairs of items — think of each pair as an object that contains both the key and the value. So to iterate the whole dictionary with foreach, you need to retrieve one of the pairs each time through the loop. The pairs are objects of type KeyValuePair<TKey, TValue>. In the WriteLine() call, I use the pair's Key and Value properties to extract the items. Here's what it looks like:

// Iterate the dictionary's contents with foreach.
// Note that you're iterating pairs of keys and values.
Console.WriteLine("
Contents of the dictionary:");
foreach (KeyValuePair<string, string> pair in dict)
{

// Because the key happens to be a string, we can call string methods on it.
  Console.WriteLine("Key: " + pair.Key.PadRight(8) + "Value: " + pair.Value);
}

In the final segment of the example program, you can see how to iterate just the keys or just the values. The dictionary's Keys property returns another collection: a list-shaped collection of type Dictionary<TKey, TValue>.KeyCollection. Because the keys happen to be strings, you can iterate the keys as strings and call string methods on them. The Values property is similar. The final bit of code uses the dictionary's Count property to see how many key/value pairs it contains.

// List the keys, which are in no particular order.
Console.WriteLine("
Just the keys:");
// Dictionary<TKey, TValue>.KeyCollection is a collection of just the keys,
// in this case strings. So here's how to retrieve the keys:
Dictionary<string, string>.KeyCollection keys = dict.Keys;
foreach(string key in keys)
{
  Console.WriteLine("Key: " + key);
}

// List the values, which are in same order as key collection above.
Console.WriteLine("
Just the values:");
Dictionary<string, string>.ValueCollection values = dict.Values;
foreach (string value in values)
{
  Console.WriteLine("Value: " + value);
}
Console.Write("
Number of items in the dictionary: " + dict.Count);

Of course, that doesn't exhaust the possibilities for working with dictionaries. Look up generic dictionary in the Help index for all the details.

In this section, I summarize initialization techniques for both arrays and collections — both old-style and new. You may want to bend the page corner.

int[] numbers = { 1, 2, 3 };           // Shorter form -- can't use var.
var numbers = new [] { 1, 2, 3 };      // Full initializer mandatory with var.

List<int> numList = new List<int>();        // New empty list.
numbers.Add(1);                             // Add elements one at a time.
numbers.Add(2);
numbers.Add(3);                             // ...tedious!

List<int> numList = new List<int>(numbers); // Initializing from an array or...
List<int> numList2 = new List<int>(numList);// from another collection or...
numList.AddRange(numbers);                  // using AddRange

List<int> numList = new List<int> { 1, 2, 3 };  // List
int[] intArray = { 1, 2, 3 };                   // Array

var list = new List<string> { "Head", "Heart", "Hands", "Health" };

Dynamic list = new List<string> { "Head", "Heart", "Hands", "Health" };

Dictionary<int, string> dict =
  new Dictionary<int, string> { { 1, "Sam" }, { 2, "Joe" } };

HashSet<int> biggerPrimes = new HashSet<int> { 19, 23, 29, 31, 37, 41 };

C# 3.0 added the new collection type HashSet<T>. A set is an unordered collection with no duplicate items.

The set concept comes from mathematics. Think of the set of genders (female and male), the set of days in a week, or the set of variations on the triangle (isosceles, equilateral, scalene, right, obtuse). Unlike math sets, C# sets can't be infinite, though they can be as large as available memory.

You can do things to a set in common with other collections, such as add, delete, and find items. But you can also perform several specifically set-like operations, such as union and intersection. Union joins the members of two sets into one. Intersection finds the overlap between two sets and results in a set containing only the overlapping members. So sets are good for combining and eliminating items.

HashSet<int> smallPrimeNumbers = new HashSet<int>();
smallPrimeNumbers.Add(2);
smallPrimeNumbers.Add(3);

Or, more conveniently, you can use a collection initializer:

HashSet<int> smallPrimeNumbers = new HashSet<int> { 2, 3, 5, 7, 11, 13 };

Or create the set from an existing collection of any list-like kind, including arrays:

List<int> intList = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7 };
HashSet<int> numbers = new HashSet<int>(intList);

If you attempt to add to a hash set an item that the set already contains, as in this example:

smallPrimeNumbers.Add(2);

the compiler doesn't treat the duplication as an error (and doesn't change the hash set, which can't have duplicates). Actually, Add() returns true if the addition occurred and false if it didn't. You don't have to use that fact, but it can be useful if you want to do something when an attempt is made to add a duplicate:

bool successful = smallPrimeNumbers.Add(2);
if(successful)
{
  // 2 was added, now do something useful.
}
// If successful is false, not added because it was already there

The first segment of this code starts with a List<string> and an array. Each contains color names. Though you could combine the two by simply calling the list's AddRange() method:

colors.AddRange(moreColors);

the resulting list contains some duplicates (yellow, orange). Using a HashSet<T> and the UnionWith() method, on the other hand, you can combine two collections and eliminate any duplicates in one shot, as the following example shows.

Console.WriteLine("Combining two collections with no duplicates:");
List<string> colors = new List<string> { "red", "orange", "yellow" };
string[] moreColors = { "orange", "yellow", "green", "blue", "violet" };
// Want to combine but without any duplicates.
// Following is just the first stage ...
HashSet<string> combined = new HashSet<string>(colors);
// ... now for the second stage.
// UnionWith() collects items in both lists that aren't duplicated,
// resulting in a combined collection whose members are all unique.
combined.UnionWith(moreColors);
foreach (string color in combined)
{
  Console.WriteLine(color);
}

The result given here contains "red", "orange", "yellow", "green", "blue", and "violet". The first stage uses the colors list to initialize a new HashSet<T>. The second stage then calls the set's UnionWith() method to add in the moreColors array — but adding only the ones not already in the set. The set ends up containing just the colors in both original lists. Green, blue, and violet come from the second list; red, orange, and yellow come from the first. The moreColors array's orange and yellow would duplicate the ones already in the set, so they're screened out.

But suppose that you want to end up with a List<T> containing those colors, not a HashSet<T>. The next segment shows how to create a new List<T> initialized with the combined set:

Console.WriteLine("
Converting the combined set to a list:");
  // Initialize a new List from the combined set above.
  List<string> spectrum = new List<string>(combined);
  foreach(string color in spectrum)
  {
    Console.WriteLine(color);
  }

Back when these examples were written, the 2008 U.S. presidential campaign was in full swing, with about ten early candidates in each major party. A good many of those candidates were also members of the U.S. Senate. How can you produce a list of just the candidates who are also in the Senate? The HashSet<T> IntersectWith() method gives you the overlapping items between the candidate list and the Senate list — items in both lists, but only those items:

Console.WriteLine("
Finding the overlap in two lists:");
List<string> presidentialCandidates =
  new List<string> { "Clinton", "Edwards", "Giuliani", "McCain", "Obama", "Romney" };
List<string> senators = new List<string> { "Alexander", "Boxer", "Clinton", "McCain", "Obama", "Snowe" };
HashSet<string> senatorsRunning = new HashSet<string>(presidentialCandidates);
// IntersectWith() collects items that appear in both lists, eliminates others.
senatorsRunning.IntersectWith(senators);
foreach (string senator in senatorsRunning)
{
  Console.WriteLine(senator);
}

The result is "Clinton", "McCain", "Obama" because those are the only ones in both lists. The opposite trick is to remove any items that appear in both of two lists so that you end up with just the items in your target list that aren't duplicated in the other list. This calls for the HashSet<T> method ExceptWith():

Console.WriteLine("
Excluding items from a list:");
Queue<int> queue =
  new Queue<int>(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 17 });
HashSet<int> unique = new HashSet<int> { 1, 3, 5, 7, 9, 11, 13, 15 };
// ExceptWith() removes items in unique that are also in queue: 1, 3, 5, 7.
unique.ExceptWith(queue);
foreach (int n in unique)
{
  Console.WriteLine(n.ToString());
}

After this code, unique excludes its own items that duplicate items in queue (1, 3, 5, 7, and 9) and also excludes items in queue that aren't in unique (0, 2, 4, 6, 8, and 17). You end up with 11, 13, and 15 in unique.

Meanwhile, the next code segment uses the SymmetricExceptWith() method to create the opposite result from IntersectWith(). Whereas intersection gives you the overlapping items, SymmetricExceptWith() gives you the items in both lists that don't overlap. The uniqueToOne set ends up containing just 5, 3, 1, 12, and 10:

Console.WriteLine("
Finding just the non-overlapping items in two lists:");
  Stack<int> stackOne = new Stack<int>(new int[] { 1, 2, 3, 4, 5, 6, 7, 8 });
  Stack<int> stackTwo = new Stack<int>(new int[] { 2, 4, 6, 7, 8, 10, 12 });
  HashSet<int> nonoverlapping = new HashSet<int>(stackOne);
  // SymmetricExceptWith() collects items that are in one collection but not
  // the other: the items that don't overlap.
  nonoverlapping.SymmetricExceptWith(stackTwo);
  foreach(int n in nonoverlapping)
  {
    Console.WriteLine(n.ToString());
  }
  Console.WriteLine("Press Enter to terminate...");
  Console.Read();
}

My use of stacks here is a bit unorthodox because I add all members at one time rather than push each one, and I remove a bunch at a time rather than pop each one. Those operations — pushing and popping — are the correct ways to interact with a stack.

Notice that all the HashSet<T> methods I demonstrate are void methods — they don't return a value. Thus the results are reflected directly in the hash set on which you call these methods: nonoverlapping in the preceding code example.

When would you use HashSet<T>? Any time you're working with two or more collections and you want to find such items as the overlap — or create a collection that contains two other collections or exclude a group of items from a collection — sets can be useful. Many of the HashSet<T> methods can relate sets and other collection classes. You can do more with sets, of course, so look up the term HashSet<T> in Help and play with HashSetExample.

At the dawn of time, before C# 2.0, when Zarathustra spake, all collection classes were implemented as collections of type Object. You couldn't create a collection just for strings or just for ints. Such a collection lets you store any type of data, because all objects in C# are derived from class Object. Thus you can add both ints and strings to the same collection without seeing error messages (because of the inheritance and polymorphism of C#, which I discuss in Book II ).

But a serious drawback occurs in the Object-based arrangement: To extract the int that you know you put into a collection, you must cast out to an int the Object you get:

ArrayList ints = new ArrayList();  // An old-fashioned list of Objects
int myInt = (int)ints[0];          // Extract the first int in the list.

It's as though your ints were hidden inside Easter eggs. If you don't cast, you create errors because, for instance, Object doesn't support the + operation or other methods, properties, and operators that you expect on ints. You can work with these limitations, but this kind of code is error-prone, and it's just plain tedious to do all that casting. (Besides, as I discuss in Book II, working with Easter eggs adds some processing overhead because of the "boxing" phenomenon. Too much boxing slows your program.)

And, if the collection happens to contain objects of more than one type — pomegranates and basketballs, say — the problem becomes tougher. Somehow, you have to detect that the object you fish out is a pomegranate or a basketball so that you can cast it correctly.

With those limitations on the older, nongeneric collections, the newer generic ones are a gale of fresh air. You never have to cast, and you always know what you're getting because you can put only one type into any given collection. But you still see the older collections occasionally, in code that other people write — and sometimes you may even have a legitimate reason to stick apples and oranges in the same collection.