Exercise 1:

using System;
using System.Collections.ObjectModel; using System.Collections.Generic;

class BasicCollectionDemo{ public static void Main(){

// Initialization - use of a collection initializer. After that add 2 elements.

IList<char> lst =
new Collection<char>{'a', 'b','c'};
lst.Add('d'); lst.Add('e');
ReportList("Initial List", lst);

// Mutate existing elements in the list: lst[0] =

'z'; lst[1]++;
ReportList("lst[0] = 'z'; lst[1]++;", lst);

// Insert and push towards the end:

lst.Insert(0,'n');
ReportList("lst.Insert(0,'n');", lst);

// Insert at end - with Insert:

lst.Insert(lst.Count,'x'); // equivalent to lst.Add('x');
ReportList("lst.Insert(lst.Count,'x');", lst);

// Remove element 0 and pull toward the beginning:

lst.RemoveAt(0);
ReportList("lst.RemoveAt(0);", lst);

// Remove first occurrence of 'c':

lst.Remove('c');
ReportList("lst.Remove('c');", lst);
// Remove remaining elements: lst.Clear();
ReportList("lst.Clear(); ", lst);
}
public static void ReportList<T>(string explanation, IList<T> list)
{ Console.WriteLine(explanation);
foreach(T el in list)
Console.Write("{0, 3}", el);
Console.WriteLine(); Console.WriteLine();
}

c static void ReportList<T>(string explanation, IList<T> list)

{
try
{
FileStream oFileStream = new FileStream(@"G:\testLogInfo1.txt", FileMode.Open,
FileAccess.Write); publi
StreamWriter oStreamWriter = new StreamWriter(oFileStream);
oFileStream.Seek(0, SeekOrigin.End);
oStreamWriter.WriteLine(explanation);
foreach (T el in list) oStreamWriter.Write(el);
oStreamWriter.WriteLine();
oStreamWriter.WriteLine();
oStreamWriter.Close();

}
catch(Exception ex)
{
MessageBox.Show(ex.ToString());
 }
}
Exercise 2:
Let us now assume that we wish to make our own, specialized (non-generic) collection class of a particular type of
objects. Below we will - for illustrative purposes - write a class called AnimalFarm which is intended to hold
instances of class Animal. It is reasonable to program AnimalFarm as a subclass of an existing collection class. In this
section we shall see that Collection<Animal> is a good choice of superclass of AnimalFarm.
The class AnimalFarm depends on the class Animal. You are invited to take a look at class Animal via the
accompanying slide . We do not include class Animal here because it does not add new insight to our interests in
collection classes. The four operations of class AnimalFarm are shown below.

using System;
using System.Collections.ObjectModel;

public class AnimalFarm: Collection<Animal>{

protected override void InsertItem(int i, Animal a)

{ base.InsertItem(i,a); Console.WriteLine("**InsertItem:
{0}, {1}", i, a);
}

protected override void SetItem(int i, Animal a)

{ base.SetItem(i,a); Console.WriteLine("**SetItem: {0},
{1}", i, a);
}

protected override void RemoveItem(int i)

{ base.RemoveItem(i);
Console.WriteLine("**RemoveItem: {0}", i);
}

protected override void ClearItems()

{ base.ClearItems();
Console.WriteLine("**ClearItems");
}
}

It is important to notice that the four highlighted operations in Program 45.3 are redefinitions of virtual, protected
methods in Collection<Animal>. Each of the methods activate the similar method in the superclass (this is method
combination). In addition, they reveal on standard output that the protected method has been called. A more realistic
example of class AnimalFarm will be presented in Program 45.6.

The four operations are not part of the client interface of class AnimalFarm. They are protected operations. The client
interface of AnimalFarm is identical to the public operations inherited from Collection<Animal>. It means that we
use the operations Add, Insert, Remove etc. on instances of class AnimalFarm.

Exercise 3:
We should now understand the role of the four protected operations InsertItem, RemoveItem, SetItem, and ClearItems
relative to the operations in the public client interface. Whenever an element is inserted into a collection, the
protected method InsertItem is called. Both Add and Insert are programmed by use of InsertItem. Similarly, both
Remove and RemoveAt are programmed by use of RemoveItem. And so on. We see that the major functionality
behind the operations in Collection<T> is controlled by the four protected methods InsertItem, RemoveItem, SetItem,
and ClearItems
using System;
using System.Collections.ObjectModel;
class App{

public static void Main(){

AnimalFarm af = new AnimalFarm();

// Populating the farm with Add

af.Add(new Animal("elephant"));
af.Add(new Animal("giraffe"));
af.Add(new Animal("tiger"));
ReportList("Adding elephant, giraffe, and tiger with Add(...)", af);

// Additional population with Insert

af.Insert(0, new Animal("dog"));
af.Insert(0, new Animal("cat"));
ReportList("Inserting dog and cat at index 0 with Insert(0, ...)", af);

// Mutate the animal farm:

af[1] = new Animal("herring", AnimalGroup.Fish, Sex.Male);
ReportList("After af[1] = herring", af);

// Remove tiger
af.Remove(new Animal("tiger"));
ReportList("Removing tiger with Remove(...)", af);

// Remove animal at index 2

af.RemoveAt(2);
ReportList("Removing animal at index 2, with RemoveAt(2)", af);

// Clear the farm

af.Clear();
ReportList("Clear the farm with Clear()", af);
}

public static void ReportList<T>(string explanation, Collection<T> list){

Console.WriteLine(explanation);
foreach(T el in list)
Console.WriteLine("{0, 3}", el);
Console.WriteLine(); Console.WriteLine();
}
}
 Exercise 4: Specialization of Collections - a realistic example
The protected methods in class AnimalFarm, as shown, did only reveal if/when the protected methods were called
by other methods. In this section we will show a more realistic example that redefines the four protected methods
of Collection<T> in a more useful way.

In the example we program the following semantics of the insertion and removal operations of class AnimalFarm:

 If we add an animal, an additional animal of the opposite sex is also added.

 Any animal removal or clearing of an animal farm is rejected.

In addition, we add a GetGroup operation to AnimalFarm, which returns a collection (a sub animal farm) of all
animals that belongs to a given group (such as all birds).

using System;
using System.Collections.ObjectModel;

public class AnimalFarm: Collection<Animal>{

// Auto insert animal of opposite sex

protected override void InsertItem(int i, Animal a){
if(a.Sex == Sex.Male){
base.InsertItem(i,a);
base.InsertItem(i, new Animal(a.Name, a.Group, Sex.Female));
} else {
base.InsertItem(i,a);
base.InsertItem(i,new Animal(a.Name, a.Group, Sex.Male));
}
}

// Prevent removal
protected override void RemoveItem(int i){
Console.WriteLine("[Removal denied]");
}

// Prevent clearing
protected override void ClearItems(){
Console.WriteLine("[Clearing denied]");
}

// Return all male animals in a given group

public AnimalFarm GetGroup(AnimalGroup g){
AnimalFarm res = new AnimalFarm();
foreach(Animal a in this)
if (a.Group == g && a.Sex == Sex.Male) res.Add(a);
return res;
}

}
Exercise 5: Sample use of class List<T>
In this and the following sections we will show how to use some of the operations in List<T>. We start with a basic
example in which we work on a list of characters: List<char>. We insert a number of char values into a list, and we
remove some values as well. Notice in particular how the range operations InsertRange (line 28) and RemoveRange
(line 40) operate on the list.
using System;
using System.Collections.Generic;

/* Very similar to our illustration of class Collection<char> */

class BasicListDemo{

public static void Main(){ // List initialization and adding elements to the end of the
list:

List<char> lst = new List<char>{'a', 'b', 'c'};

lst.Add('d'); lst.Add('e');
ReportList("Initial list, followed by lst.Add('d'); lst.Add('e');", lst);
// Mutate existing elements in the list
lst[0] = 'z'; lst[1]++;
ReportList("lst[0] = 'z'; lst[1]++;", lst);

// Insert and push towards the end

lst.Insert(0,'n');
ReportList("lst.Insert(0,'n');", lst);

// Insert at end - with Insert

lst.Insert(lst.Count,'x'); // equivalent to lst.Add('x');
ReportList("lst.Insert(lst.Count,'x');", lst);

// Insert a new list into existing list, at position 2.

lst.InsertRange(2, new List<char>{'1', '2', '3', '4'});
ReportList("lst.InsertRange(2, new List<char>{'1', '2', '3', '4'});", lst);

// Remove element 0 and push toward the beginning

lst.RemoveAt(0);
ReportList("lst.RemoveAt(0);", lst);

// Remove first occurrence of 'c'

lst.Remove('c');
ReportList("lst.Remove('c');", lst);

// Remove 2 elements, starting at element 1

lst.RemoveRange(1, 2);
ReportList("lst.RemoveRange(1, 2);", lst);

// Remove all remaining digits

lst.RemoveAll(delegate(char ch){return Char.IsDigit(ch);});
ReportList("lst.RemoveAll(delegate(char ch){return Char.IsDigit(ch);});", lst);

// Test of all remaining characters are letters

if (lst.TrueForAll(delegate(char ch){return Char.IsLetter(ch);}))
Console.WriteLine("All characters in lst are letters");
else
Console.WriteLine("NOT All characters in lst are letters");
}
 public static void ReportList<T>(string explanation, List<T> list){
Console.WriteLine(explanation);
foreach(T el in list)
Console.Write("{0, 3}", el);
Console.WriteLine(); Console.WriteLine();
}

Exercise 6: Sample use of the Find operations in List<T>

In this section we will illustrate how to use the search operations in List<T>. More specifically, we will apply the
methods Find, FindAll and IndexOf on an instance of List<Point>, where Point is a type, such as defined by the
struct in the Program. The operations discussed in this section do all use linear search. It means that they work by
looking at one element after the other, in a rather trivial way. As a contrast, we will look at binary search operations
which searches in a "more advanced" way.
In the program below - we declare a List<Point> in line 11, and we add six points to the list in line 13-16. In line 20
we shown how to use Find to locate the first point in the list whose x-coordinate is equal to 5. The same is shown in
line 25. The difference between the two uses of Find is that the first relies on a delegate given on the fly:
delegate(Point q){return (q.Getx() == 5);}, while the other relies on an existing static method FindX5 (defined in line
40 - 42). The approach shown in line 20 is, in my opinion, superior.

In line 29 we show how to use the variant FindAll, which returns a Point list instead of just a single Point, as returned
by Find. In line 36 we show how IndexOf can be used to find the index of a given Point in a Point list. It is worth
asking how the Point parameter of IndexOf is compared with the points in Point list. The documentation states that
the points are compared by use of the default equality comparer of the type T, which in our case is struct Point. We
have discussed the default equality comparer in the slipstream of our coverage of the generic interfaces
IEquatable<T> and IEqualityComparer<T>.
We use the static method ReportList to show a Point list on standard output. We call ReportList several times.

using System;
using System.Collections.Generic;

class C{

public static void Main(){

System.Threading.Thread.CurrentThread.CurrentCulture =
new System.Globalization.CultureInfo("en-US");

List<Point> pointLst = new List<Point>();

// Construct points and point list:

pointLst.Add(new Point(0,0)); pointLst.Add(new Point(5, 9));
pointLst.Add(new Point(5,4)); pointLst.Add(new Point(7.1,-13));
pointLst.Add(new Point(5,-2)); pointLst.Add(new Point(14,-3.4));
ReportList("Initial point list", pointLst);

// Find first point in list with x coordinate 5

Point p = pointLst.Find(delegate(Point q){return (q.Getx() == 5);});
Console.WriteLine("Found with delegate predicate: {0}\n", p);

// Equivalent. Use predicate which is a static method

p = pointLst.Find(new Predicate<Point>(FindX5));
 Console.WriteLine("Found with static member predicate: {0}\n", p);

// Find all points in list with x coordinate 5

List<Point> resLst = new List<Point>();
resLst = pointLst.FindAll(delegate(Point q){return (q.Getx() == 5);});
ReportList("All points with x coordinate 5", resLst);

// Find index of a given point in pointLst.

// Notice that Point happens to be a struct - thus value comparison
Point searchPoint = new Point(5,4);
Console.WriteLine("Index of {0} {1}", searchPoint,
pointLst.IndexOf(searchPoint));

}
public static bool FindX5(Point p){
return p.Getx() == 5;
}

public static void ReportList<T>(string explanation,List<T> list){

Console.WriteLine(explanation);
int cnt = 0;
foreach(T el in list){
Console.Write("{0, 3}", el);
cnt++;
if (cnt%4 == 0) Console.WriteLine();
}
if (cnt%4 != 0) Console.WriteLine();
Console.WriteLine();
}
}

Exercise 7: Sample use of Sort in List<T>

As a client user of the generic class List<T> it is likely that you never need to write a sorting procedure! You are
supposed to use one of the already existing Sort methods in List<T>.

Sorting the elements in a collection of elements of type T depends on a less than or equal operation on T. If the type
T is taken directly from the C# libraries, it may very well be the case that we can just use the default less than or
equal operation of the type T. If T is one of our own types, we will have to supply an implementation of the
comparison operation ourselves. This can be done by passing a delegate object to the Sort method.

Below, we illustrate most of the four overloaded Sort operations in List<T>. The actual type parameter in the
example, passed for T, is int.

using System;
using System.Collections.Generic;

class C{

public static void Main(){

List<int> listOriginal = new List<int>{5, 3, 2, 7, -4, 0},

list;

// Sorting by means of the default comparer of int:

list = new List<int>(listOriginal);
 ReportList(list);
list.Sort();
ReportList(list);
Console.WriteLine();

// Equivalent - explicit notatation of the Comparer:

list = new List<int>(listOriginal);
ReportList(list);
list.Sort(Comparer<int>.Default);
ReportList(list);
Console.WriteLine();

// Equivalent - explicit instantiation of an IntComparer:

list = new List<int>(listOriginal);
ReportList(list);
list.Sort(new IntComparer());
ReportList(list);
Console.WriteLine();
// Similar - use of a delegate value for comparison:
list = new List<int>(listOriginal);
ReportList(list);
list.Sort(delegate(int x, int y){
if (x < y)
return -1;
else if (x == y)
return 0;
else return 1;});
ReportList(list);
Console.WriteLine();
}

public static void ReportList<T>(List<T> list){

foreach(T el in list)
Console.Write("{0, 3}", el);
Console.WriteLine();
}

public class IntComparer: Comparer<int>{

public override int Compare(int x, int y){
if (x < y)
return -1;
else if (x == y)
return 0;
else return 1;
}
}

Throughout the Program we do several sortings of listOriginal, as declared in line 8. In line 14 we rely the default
comparer of type int. The default comparer is explained in the following way in the .NET framework documentation
of List.Sort:
This method uses the default comparer Comparer.Default for type T to determine the order of list elements. The
Comparer.Default property checks whether type T implements the IComparable generic interface and uses that
implementation, if available. If not, Comparer.Default checks whether type T implements the IComparable interface.
If type T does not implement either interface, Comparer.Default throws an InvalidOperationException.
The sorting done in line 21 is equivalent to line 14. In line 21 we show how to pass the default comparer of type int
explicitly to the Sort method.
Let us now assume the type int does not have a default comparer. In other words, we will have to implement the
comparer ourselves. The call of Sort in line 28 passes a new IntComparer instance to Sort. The class IntComparer is
programmed in line 53-61, at the bottom. Notice that IntComparer is a subclass of Comparer<int>, which is an
abstract class in the namespace System.Collections.Genericwith an abstract method named Compare. The generic
class Comparer<T> is in many ways similar to the class EqualityComparer<T>. Most important, both have a static
Default property, which returns a comparer object.
As a final resort that always works we can pass a comparer function to Sort. In C#, such a function is programmed as
a delegate. (Delegates are discussed in Chapter 22). Line 35-40 shows how this can be done. Notice that the delegate
we use is programmed on the fly. This style of programming is a reminiscence of functional programming.

I find it much more natural to pass an ordering method instead of an object of a class with an ordering method. (The
latter is a left over from older object-oriented programming languages in which the only way to pass a function F as
parameter is via an object of a class in which F is an instance method). In general, I also prefer to be explicit about
the ordering instead of relying on some default ordering which may turn out to surprise you.

Let us summarize the lessons that we have learned from the example:
 Some types have a default comparer which is used by List.Sort()
 The default comparer of T can extracted by Comparer<T>.Default
 An anonymous delegate comparer is attractive if the default comparer of the type does not exist, of if it is
inappropriate.

Exercise 8: Sample use of BinarySearch in List<T>

The search operations discussed in Section 45.11 all implemented linear search processes. The search operations of
this section implement binary search processes, which are much faster when applied on large collections. On
collections of size n, linear search has - not surprisingly - time complexity O(n). Binary search has time complexity
O(log n). When n is large, the difference between n and log n is dramatic.

The BinarySearch operations in List<T> require, as a precondition, that the list is ordered before the search is
performed. If necessary, the Sort operation (see Section 45.12) can be used to establish the ordering.

You may ask why we should search for an element which we - in the starting point - is able to pass as input to the
BinarySearch method. There is a couple of good answers. First, we may be interested to know if the element is
present or not in the list. Second, it may also be possible to search for an incomplete object (by only comparing some
selected fields in the Comparer method). Using this approach we are actually interested in finding the complete
object, with all the data fields, in the collection.
If the BinarySearch operation finds an element in the list, the index of the element is returned. This is a non- negative
integer. If the element is not found, a negative integer, say i, is returned. Below we will see that that -i (or more
precisely the bitwise complement ~i) in that case is the position of the element, if it had been present in the list.

using System;
using System.Collections.Generic;

class BinarySearchDemo{

public static void Main(){

System.Threading.Thread.CurrentThread.CurrentCulture =
new System.Globalization.CultureInfo("en-US");

List<Point> pointLst = new List<Point>(); // Point is a struct.

// Construct points and point list:

pointLst.Add(new Point(0,0)); pointLst.Add(new Point(5, 9));
pointLst.Add(new Point(5,4)); pointLst.Add(new Point(7.1,-13));
pointLst.Add(new Point(5,-2)); pointLst.Add(new Point(14,-3.4));
ReportList("The initial point list", pointLst);
// Sort point list, using a specific point Comparer.
// Notice the PointComparer:
// Ordering according to sum of x and y coordinates
IComparer<Point> pointComparer = new PointComparer();
pointLst.Sort(pointComparer);
ReportList("The sorted point list", pointLst);

int res;
Point searchPoint;

// Run-time error.
// Failed to compare two elements in the array.
// searchPoint = new Point(5,4);
// res = pointLst.BinarySearch(searchPoint);
// Console.WriteLine("BinarySearch for {0}: {1}", searchPoint, res);

searchPoint = new Point(5,4);

res = pointLst.BinarySearch(searchPoint, pointComparer);
Console.WriteLine("BinarySearch for {0}: {1}", searchPoint, res);

searchPoint = new Point(1,8);

res = pointLst.BinarySearch(searchPoint, pointComparer);
Console.WriteLine("BinarySearch for {0}: {1}", searchPoint, res);

public static void ReportList<T>(string explanation,List<T> list){

Console.WriteLine(explanation);
int cnt = 0;
foreach(T el in list){
Console.Write("{0, 3}", el);
cnt++;
if (cnt%4 == 0) Console.WriteLine();
}
if (cnt%4 != 0) Console.WriteLine();
Console.WriteLine();
}

// Compare the sum of the x and y coordinates.

// Somewhat non-traditional!
public class PointComparer: Comparer<Point>{
public override int Compare(Point p1, Point p2){
double p1Sum = p1.Getx() + p1.Gety();
double p2Sum = p2.Getx() + p2.Gety();
if (p1Sum < p2Sum)
return -1;
else if (p1Sum == p2Sum)
return 0;
else return 1;
}
}
Exercise 9: Sample use of BinarySearch in List<T>
In the next program, we illustrate what happens if we search for a non-existing point with BinarySearch. The class
PointComparer and the generic method ReportList are not shown in the paper version.
using System;
using System.Collections.Generic;

class BinarySearchDemo{

public static void Main(){

System.Threading.Thread.CurrentThread.CurrentCulture =
new System.Globalization.CultureInfo("en-US");

List<Point> pointLst = new List<Point>();

// Construct points and point list:

pointLst.Add(new Point(0,0)); pointLst.Add(new Point(5, 9));
pointLst.Add(new Point(5,4)); pointLst.Add(new Point(7.1,-13));
pointLst.Add(new Point(5,-2)); pointLst.Add(new Point(14,-3.4));
ReportList("Initial point list", pointLst);

// Sort point list, using a specific point Comparer:

IComparer<Point> pointComparer = new PointComparer();
pointLst.Sort(pointComparer);
ReportList("Sorted point list", pointLst);

int res;
Point searchPoint;

searchPoint = new Point(1,1);

res = pointLst.BinarySearch(searchPoint, pointComparer);
Console.WriteLine("BinarySearch for {0}: {1}\n", searchPoint, res);

if (res < 0){ // search point not found

pointLst.Insert(~res, searchPoint); // Insert searchPoint such
// that pointLst remains sorted
Console.WriteLine("Inserting {0} at index {1}", searchPoint, ~res);
ReportList("Point list after insertion", pointLst);
}
}

public static void ReportList<T>(string explanation,List<T> list){

Console.WriteLine(explanation);
int cnt = 0;
foreach(T el in list){
Console.Write("{0, 3}", el);
cnt++;
if (cnt%4 == 0) Console.WriteLine();
}
if (cnt%4 != 0) Console.WriteLine();
Console.WriteLine();
}

// Compare the sum of the x and y coordinates.

// Somewhat non-traditional!
public class PointComparer: Comparer<Point>{
public override int Compare(Point p1, Point p2){
double p1Sum = p1.Getx() + p1.Gety();
double p2Sum = p2.Getx() + p2.Gety();
if (p1Sum < p2Sum)
return -1;
else if (p1Sum == p2Sum)
return 0;
else return 1;
}
}
we do binary searching, looking for the point (1,1). None of the points in the program have an "x plus y sum" of 2.
Therefore, the point (1,1) is not located by BinarySearch. The BinarySearch method returns a negative ghost index.
The ghost index is the bitwise complement of the index where to insert the point in such a way that the list will
remain sorted. (Notice the bitwise complement operation ~ which turns 0 to 1 and 1 to 0 at the binary level). The
program output reveals that position ~(-3) is the natural place of the point (1,1) to maintain the ordering of the list.
Notice that the value of ~(-3) is 2, due the use of two's complement arithmetic. This explains the rationale of the
negative values returned by BinarySearch.

Contrary to Sort, it is not possible to pass a delegate to BinarySearch. This seems to be a flaw in the design of the
List<T> library.

We have learned the following lessons about BinarySearch:

 Binary search can only be done on sorted lists
 In order to use binary search, we need - in general - to provide an explicit Comparer object
 Binary search returns a (non-negative) integer if the element is found
 The index of the located element
 Binary search returns a negative integer if the element is not found
 The complement of this number is a ghost index
 The index of the element if it had been in the list

Exercise 10: Sample use of class LinkedList<T>

We will illustrate the use of LinkedList<T> and LinkedListNode<T> in Program 45.19. In line 8 we make a linked
list of integers from an array. Notice the use of the LinkedList constructor LinkedList(IEnumerable<T>).
In line 16 we attempt to add the integer 17 to the linked list. This is not possible, because the method Add is not
easily available, see the discussion in Section 45.14. If we insist to use Add, it must be done as in line 20. Most likely,
you should use one of the Add variants instead, for instance AddFirst or AddLast.

using System;
using System.Collections.Generic;

class LinkedListDemo{

public static void Main(){

LinkedList<int> lst = new LinkedList<int>(

new int[]{5, 3, 2, 7, -4, 0});

ReportList("Initial LinkedList", lst);

// Using Add.
// Compile-time error: 'LinkedList<int>' does not contain a
// definition for 'Add'
// lst.Add(17);
// ReportList("lst.Add(17);" lst);
// Add is implemented as an explicit interface implementation
((ICollection<int>)lst).Add(17);
ReportList("((ICollection<int>)lst).Add(17);", lst);

// Using AddFirst and AddLast

lst.AddFirst(-88);
lst.AddLast(88);
ReportList("lst.AddFirst(-88); lst.AddFirst(88);", lst);

// Using Remove.
lst.Remove(17);
ReportList("lst.Remove(17);", lst);

// Using RemoveFirst and RemoveLast

lst.RemoveFirst(); lst.RemoveLast();
ReportList("lst.RemoveFirst(); lst.RemoveLast();", lst);

// Using Clear
lst.Clear();
ReportList("lst.Clear();", lst);

public static void ReportList<T>(string explanation, LinkedList<T> list){

Console.WriteLine(explanation);
foreach(T el in list)
Console.Write("{0, 4}", el);
Console.WriteLine(); Console.WriteLine();
}

Initial LinkedList

5 3 2 7 -4 0

((ICollection<int>)lst).Add(17);
5 3 2 7 -4 0 17

lst.AddFirst(-88); lst.AddFirst(88);

-88 5 3 2 7 -4 0 17 88

lst.Remove(17);

-88 5 3 2 7 -4 0 88
Program 45.19 Basic operations on a LinkedList of integers.
Listing 45.20 Output of the program with basic operations on a LinkedList.
The LinkedList example in Program 45.19 did not show how to use LinkedListNodes
together with LinkedList<T>. To make up for that we will in Program 45.21 concentrate on
the use of LinkedList<T> and LinkedListNode<T> together.
using System;
using System.Collections.Generic;

class LinkedListNodeDemo{

public static void Main(){

LinkedList<int> lst = new LinkedList<int>(

new int[]{5, 3, 2, 7, -4, 0});
ReportList("Initial LinkedList", lst);

LinkedListNode<int> node1, node2, node;

node1 = lst.First;
node2 = lst.Last;

// Run-time error.
// The LinkedListNode is already in the list.
// Error message: The LinkedList node belongs a LinkedList.
/* lst.AddLast(node1); */

// Move first node to last node in list

lst.Remove(node1); lst.AddLast(node1);
ReportList("node1 = lst.First; lst.Remove(node1); lst.AddLast(node1);", lst);

// Navigate in list via LinkedListNode objects

node1 = lst.First;
Console.WriteLine("Third element in list: node1=lst.First;node1.Next.Next.Value=={0}\n",
node1.Next.Next.Value);

// Add an integer after a LinkedListNode object

lst.AddAfter(node1, 17);
ReportList("lst.AddAfter(node1, 17);", lst);

// Add a LinkedListNode object after another LinkedListNode object

lst.AddAfter(node1, new LinkedListNode<int>(18));
ReportList("lst.AddAfter(node1, new LinkedListNode<int>(18));" , lst);

// Navigate in LinkedListNode objects and add an int before a node:

node = node1.Next.Next.Next;
lst.AddBefore(node, 99);
ReportList("node = node1.Next.Next.Next; lst.AddBefore(node, 99); " , lst);

// Navigate in LinkedListNode objects and remove a node.

node = node.Previous;
lst.Remove(node);
ReportList("node = node.Previous; lst.Remove(node);" , lst);

public static void ReportList<T>(string explanation, LinkedList<T> list){

Console.WriteLine(explanation);
foreach(T el in list)
Console.Write("{0, 4}", el);
Console.WriteLine(); Console.WriteLine();
}

}
Program 45.21 Basic operations on a LinkedList of integers - using LinkedListNodes.
In line 8-9 we make the same initial integer list as in Program 45.19. In line 13-14 we see
how to access to the first/last LinkedListNode objects of the list.
In line 19 we attempt to add node1, which is the first LinkedListNode in lst, as the last node
of the list. This fails because it could bring the linked list into an inconsistent state. (Recall in
this context that a LinkedListNode knows the list to which it belongs). Instead, as shown in
line 22, we should first remove node1 and then add node1 with AddLast.
Exercise 11: Using Collections through Interfaces
Let us illustrate how this can be done in Program 45.23. The thing to notice is that the only
place we refer to a list class (here Collection<Animal>() ) is in line 9: new
Collection<Animal>. All other places, as emphasized with purple, we use the interface
ICollection<Animal>. If we, tomorrow, wish to change the representation of the animal
collection, the only place to modify is line 9.

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;

class CollectionInterfaceDemo{
 public static void Main(){
ICollection<Animal> lst = new Collection<Animal>();

// Add elements to the end of the empty list:

lst.Add(new Animal("Cat")); lst.Add(new Animal("Dog", Sex.Female));
lst.Add(new Animal("Mouse")); lst.Add(new Animal("Rat"));
lst.Add(new Animal("Mouse", Sex.Female)); lst.Add(new Animal("Rat"));
lst.Add(new Animal("Herring", AnimalGroup.Fish, Sex.Female));
lst.Add(new Animal("Eagle", AnimalGroup.Bird, Sex.Male));

// Report in various ways on the animal collection:

Print("Initial List", lst);
ReportFemaleMale(lst);
ReportGroup(lst);
}

public static void Print<T>(string explanation, ICollection<T> list){

Console.WriteLine(explanation);
foreach(T el in list)
Console.WriteLine("{0, 3}", el);
Console.WriteLine(); Console.WriteLine();
}

public static void ReportFemaleMale(ICollection<Animal> list){

int numberOfMales = 0,
numberOfFemales = 0;

foreach(Animal a in list)
if (a.Sex == Sex.Male) numberOfMales++;
else if (a.Sex == Sex.Female) numberOfFemales++;

Console.WriteLine("Males: {0}, Females: {1}",

numberOfMales, numberOfFemales);
}

public static void ReportGroup(ICollection<Animal> list){

int numberOfMammals = 0,
numberOfBirds = 0,
numberOfFish = 0;

foreach(Animal a in list)
if (a.Group == AnimalGroup.Mammal) numberOfMammals++;
else if (a.Group == AnimalGroup.Bird) numberOfBirds++;
else if (a.Group == AnimalGroup.Fish) numberOfFish++;

Console.WriteLine("Mammals: {0}, Birds: {1}, Fish: {2}",

numberOfMammals, numberOfBirds, numberOfFish);
}

}
Program 45.23 A program based on ICollection<Animal> - with a Collection<Animal>.
On the accompanying slide we show versions of Program 45.23, which are tightly bound to
the class Collection<Animal>, and we show a version in which we have replaced
Collection<Animal> with List<Animal>.
 Exercise 12: Sample use of class Dictionary<K,V>
In this section we will illustrate the use of dictionaries with a simple example. We go for a
dictionary that maps objects of type Person to objects of type BankAccount. Given a Person
object (the key) we wish to have efficient access to the person's BankAccount (the value).

The class Person is similar to Program 20.3. The class BankAccount is similar to Program
25.1. The exact versions of Person and BankAccount, as used in the dictionary example, can
be accessed via the accompanying slide page, or via the program index of this lecture.
using System;
using System.Collections.Generic;

class DictionaryDemo{

public static void Main(){

IDictionary<Person, BankAccount> bankMap =

new Dictionary<Person,BankAccount>(new PersonComparer());

// Make bank accounts and person objects

BankAccount ba1 = new BankAccount(0.01),
ba2 = new BankAccount(0.02),
ba3 = new BankAccount(0.03),
ba4 = new BankAccount(0.04);

Person p1 = new Person("Kurt"),

p2 = new Person("Maria"),
p3 = new Person("Francoi");

ba1.Deposit(100); ba2.Deposit(200); ba3.Deposit(300);

// Populate the bankMap:

bankMap.Add(p1, ba1);
bankMap.Add(p2, ba2);
bankMap.Add(p3, ba3);
ReportDictionary("Initial map", bankMap);

// Print Kurt's entry in the map:

Console.WriteLine("{0}\n", bankMap[p1]);

// Mutate Kurt's entry in the map

bankMap[p1] = ba4;
ReportDictionary("bankMap[p1] = ba4;", bankMap);

// Mutate Maria's entry in the map. PersonComparer crucial!

ba4.Deposit(400);
bankMap[new Person("Maria")] = ba4;
ReportDictionary("ba4.Deposit(400); bankMap[new Person(\"Maria\")] = ba4;", bankMap);
// Add p3 yet another time to the map
// Run-time error: An item with the same key has already been added.
/* bankMap.Add(p3, ba1);
ReportDictionary("bankMap.Add(p3, ba1);", bankMap);
*/

// Try getting values of some given keys

BankAccount ba1Res = null,
ba2Res = null;
bool res1 = false,
res2 = false;
res1 = bankMap.TryGetValue(p2, out ba1Res);
res2 = bankMap.TryGetValue(new Person("Anders"), out ba2Res);
Console.WriteLine("Account: {0}. Boolean result {1}", ba1Res, res1);
Console.WriteLine("Account: {0}. Boolean result {1}", ba2Res, res2);
Console.WriteLine();

// Remove an entry from the map

bankMap.Remove(p1);
ReportDictionary("bankMap.Remove(p1);", bankMap);

// Remove another entry - works because of PersonComparer

bankMap.Remove(new Person("Francoi"));
ReportDictionary("bankMap.Remove(new Person(\"Francoi\"));", bankMap);
}

public static void ReportDictionary<K, V>(string explanation,

IDictionary<K,V> dict){
Console.WriteLine(explanation);
foreach(KeyValuePair<K,V> kvp in dict)
Console.WriteLine("{0}: {1}", kvp.Key, kvp.Value);
Console.WriteLine();
}
}

public class PersonComparer: IEqualityComparer<Person>{

public bool Equals(Person p1, Person p2){

return (p1.Name == p2.Name);
}

public int GetHashCode(Person p){

return p.Name.GetHashCode();
}
}

In line 8-9 we make the dictionary bankMap of type Dictionary<Person,BankAccount>. We

pass an instance of class PersonComparer, see line 76-86, which implements
IEqualityComparer<Person>. In line 11-19 we make sample BankAccount and Person
objects, and in line 24-26 we populate the dictionary bankMap.
In line 30 we see how to access the bank account of person p1 (Kurt). We use the provided
indexer of the dictionary. In line 33 we mutate the bankMap: Kurt's bank account is changed
from the one referenced by ba1 to the one referenced by ba4. In line 38 we mutate Maria's
bank account in a similar way. Notice, however, that that the relative weak equality of Person
objects (implemented in class PersonComparer) implies that the new person("Maria") in line
38 is equal to the person referenced by p2, and therefore line 38 mutates the dictionary entry
for Maria.
In line 43 we attempt add yet another entry for Francoi. This is illegal because there is
already an entry for Francoi in the dictionary. If the comments around line 43 are removed, a
run time error will occur.

In line 52-53 we illustrate TryGetValue. First, in line 52, we attempt to access Maria's
account. The out parameter baRes1 is assigned to Maria's account and true is returned from
the method. In line 53 we attempt to access the account of a brand new Person object, which
has no bank account in the dictionary. null is returned through ba2Res, and false is returned
from the method.

Finally, in line 58-64 we remove entries from the dictionary by use of the Remove method.
First Kurt's entry is removed after which Francoi's entry is removed.

The output of the program is shown in Listing 46.2 (only on web).

Exercise 12.3. Switching from Dictionary to SortedDictionary

The program on this slide instantiates a Dictionary<Person,BankAccount>. As

recommended earlier in this lecture, we should work with the dictionary via a variable of the
interface type IDictionary<K,V>.
You are now asked to replace Dictionary<Person,BankAccount> with
SortedDictionary<Person,BankAccount> in the above mentioned program. This causes a

minor problem. Identify the problem, and fix it.

Can you tell the difference between the output of the program on this slide and the output of
your revised program?

You can access the BankAccount and Person classes in the web version of the material.