11.1 Intersection, union, and difference: Operations on sets
On the accompanying slide we have shown a generic class set<T>. Add the classical set operations intersection, union and set difference to the generic class set<T>. Test the new operations from a client program. Hint: The enumerator, that comes with the class set<T>, may be useful for the implementation of the requested set operations. 
Solution
The three requested methods Intersection, Union, and Diff appear in the middle of the following version of the generic class set<T>:

11.2 An element access operation on sets
The only way to get access to an element from a set is via use of the enumerator (also known as the iterator) of the set. In this exercise we wish to change that. Invent some operation on the set that allows you to take out an existing element in the set. This corresponds to accessing a given item in an array or a list, for instance via an indexer: arr[i] and lst[j]. Notice in this context that there is no order between elements in the set. It is not natural to talk about "the first" or "the last" element in the set. Given the invented operation in Set<T> use it to illustrate that, for some concrete type T, no casting is necessary when elements are accessed from Set<T> 
11.3 A generic Pair class
Program a generic class Pair<S,T> which aggregates two values of the types S and T respectively. It is sufficient to program nonmutable pairs. Be sure to equip the class with an appropriate constructor, and appropriate getter properties. 
Solution
Here is the class Pair<S,T>:

11.4 Comparable Pairs
This exercise is inspired by an example in the book by Hansen and Sestoft: C# Precisely. Program a class ComparablePair<T,U> which implements the interface IComparable<ComparablePair<T,U>>. If you prefer, you can build the class ComparablePair<T,U> on top of class Pair<S,T> from an earlier exercise in this lecture. It is required that T and U are types that implement Icomparable<T> and Icomparable<U> respectively. How is that expressed in the class ComparablePair<T,U>? The generic class ComparablePair<T,U> should represent a pair (t,u) of values/objects where t is of type T and u is of type U. The generic class should have an appropriate constructor that initializes both parts of the pair. In addition, there should be properties that return each of the parts. Finally, the class should  of course  implement the operation CompareTo because it is prescribed by the interface System.IComparable<ComparablePair<T,U>>. Given two pairs p = (a,b) and q= (c,d). p is considered less than q if a is less than c. If a is equal to c then b and d controls the ordering. This is similar to lexicographic ordering on strings. If needed, you may get useful inspiration from the Icomparable class String<T> on the accompanying slide. Be sure to testdrive your solution! 
Solution
The solution rely on the generic class Pair<T,S> from an earlier exercise. To be as complete as possible, we first show Pair<T,S>:
ComparablePair<T,U> is here:
Finally we show a client of ComparablePair<T,U>:
The program outputs:
The two First constituents are both 4, and thus equal to each other. The tow Second constituents are false and true, respectively. false is less than true (false.CompareTo(true) == 1), and therefore cp1.CompareTo(cp2) == 1. This ends the solution to this exercise. 
Generated: Monday February 7, 2011, 12:20:50