Object Composition

Interfaces

Collections

Covariance

Object class

Programming using C#

LECTURE 10

What’s to come today?

• Object Composition

• Collections

• Dictionaries

• Queues

• Stacks

• Interfaces

• IComparable<T> - Sorting collections

• IComparer<T> - Writing our own comparer

• Covariance

• Object class

Object Composition

• Object composition is a way of combining multiple simple

objects to create a more complex object.

• We typically use the HAS-A relationship to check whether one

object should be composed within another.

• An example of object composition,

would be a Bathroom HAS-A Tub. So

Tub, may be a property of the Bathroom

class.

Object Composition Ex.

public class Bathroom {

public Tub tub;

public Bathroom(){

this.tub = new Tub();

}

public void runBath(){

tub.Fill();

}

}

Interfaces

• Inheritance allows us to define common classes in terms of

superclass. i.e. A Car is a type of Vehicle.

• Sometimes though we may want to possibly expose a set of

methods across unrelated classes that say what an object

can do.

• An interface in C#, allows us to achieve this. An interface

essentially says here is a contract that I am exposing, but I

am providing no implementation. If you implement this

contract, then you have to provide your own

implementation for this contract.

Interfaces (continued)

• Lets take an analogy, imagine that you are a Teacher.

However also as part of your role, you are also the First Aid

Officer. A Teacher doesn’t necessarily have to be a First Aid

officer but can choose to be one. An accountant in another

company, may choose to be a First Aid Officer also.

• In this scenario, we could define an interface called

IFirstAidOfficer, that would expose methods that all First Aid

officers are expected to do. Therefore both the Teacher and

Accountant classes could implement the IFirstAidOfficer

interface and provide their own implementations.

Interfaces in C#

• An interface does not have any implementation for the

methods it defines, it delegates that to the classes that

implement it.

• Declaring an interface. We typically name an interface with a

capital I prefix:

public interface IFirstAidOfficer{

void performCPR();

}

• Implementing an interface:

public class FighterPilot : Pilot, IFirstAidOfficer{…}

This class FighterPilot inherits from Pilot and

implements IFirstAidOfficer.

Interfaces in C# (continued)

public class FighterPilot : Pilot, IFirstAidOfficer{

…

//Pilot Methods below

…

//Implementing IFirstAidOfficer

public void performCPR(){

tiltHead();

startCompressions();

}

}

Extra Collections

• A List is a very useful collection that allows us to add, remove

and retrieve items in a certain order.

• However sometimes a list may not be the best possible

implementation for certain scenarios.

• We are going to look at a few key extra collections that can be

used to mimic different functionality you require in your

program.

• These extra collections are called:

• Dictionary

• Queue

• Stack

Dictionary

• Think of an Oxford English dictionary, it contains a list

of words along the left hand side of the page alongside

with their corresponding definition.

• In programming, we also have a special type of

collection called a Dictionary that also allows us to

create a list of key-value pairs. This means that we

can specify a key, that is to be associated with certain

data – i.e. the value.

• Dictionaries are useful for quickly looking up a piece of

data.

Dictionary (continued)

• In C#, we declare a dictionary as follows:

Dictionary<TKey, TValue> kv = new

Dictionary<TKey, TValue>();

• TKey, and TValue should be replaced by the types that

you want your key and values to be. i.e. int, string etc.

• Dictionaries are very versatile, the key and value type

can be pretty much any type as long as the key is

suitable for easy lookup and the value type is what you

want to store.

Dictionary (continued)

Dictionary<String, Account> accountDict = new

Dictionary<String, Account>();

• So here we are creating a dictionary with a key of type String

which might be the account holder’s name, and a value of

type Account which is a class.

• To add items to a dictionary we use the Add method along

with the key we want to use and the value we want to

associate with this key.

accountDict.Add("Sean", new Account("Savings", 0.00));

accountDict.Add("Brian", new Account("Interest",

0.00));

Dictionary (continued)

• To retrieve the value at a certain key we use:

Account account = accountDict[“Sean”];

• To remove a item from a dictionary we specify the item via it’s

key:

accountDict.Remove(“Brian”);

• To check if a certain key exists (true or false) we use:

bool keyExists = accountDict.ContainsKey(“John”);

• To retrieve all the keys in the dictionary as an array we use:

List<string> allKeys = new

List<string>(accountDict.Keys);

Queue

• We encounter queues in every day life. For example we queue

up at shopping markets to pay for our items.

• In Computer Science, a Queue is another type of collection

that has some special properties.

• When we think of a queue at a shopping centre, we may

arrive at a till, and there may be either some customers there

or no customers.

Queue (continued)

• If there are some customers there we will join the back of the

queue. Or if there are no customers there we will immediately

get our items served.

• Sometimes we want to mimic a queue in programming, so

that items can only be accessed in a certain order.

• A queue is known as a First In First Out data structure.

Whoever is at the top of the queue will be processed next.

• In C#, we have a Queue collection that mimics this

functionality so that items can be processed in a First In First

Out (FIFO) order.

Queues in C#

• Creating a queue in C# where T can be any type.

Queue<T> queue = new Queue<T>();

Queue<Customer> customerQueue = new Queue<Customer>();

• To add an item to the back of a queue, we enqueue the item

queue.Enqueue(new Customer(“John”));

• To remove an item from the front of a queue, we dequeue the

item

Customer nextCustomer = queue.Dequeue();

• To check what is at the front or top of the queue, we can use

the method peek

Customer checkWhoIsNext = customerQueue.Peek();

Stacks

• A Stack is another special type of collection that allows you to

access data in a certain order.

• A good example of a stack is a stack of plates. When we add a

plate to the stack, it becomes the top plate on the stack. So if

we were to be remove a plate from the stack, we can only

remove the plate at the top of the stack, i.e. the one we most

recently added.

• This means that a Stack is a Last In First Out (LIFO) data

structure. I.e. the first item we get out is the last item that we

have added.

• In C#, we have a Stack collection that mimics this

functionality so that items can be processed in a Last In First

Out (LIFO) order.

Stacks in C#

• Creating a Stack in C#

Stack<T> stackName = new Stack<T>();

Stack<Plate> plates = new Stack<Plate>();

• Adding to a Stack is called pushing

plates.Push(new Plate());

• Removing the top item from a stack is called popping

Plate plate = plates.Pop();

• We can also check what is at the top of the stack by peeking

Plate plate = plates.Peek();

• We can empty a stack by clearing

plates.Clear();

Covariance

• Covariance is the act of up-casting an entire list at once to a

more general list.

• For example, if you had a list of Ducks (which are a subclass

of a Bird), and you wanted to up-cast the entire list to a list of

Birds, you would do the following:

• So we could take a llist of ducks, and assign it to a

IEnumerable<Bird> interface. Then we can add these up-

casted ducks to a list of bird objects.

• An IEnumerable is just an interface that defines generic

enumerator (iteration) methods.

Covariance Example

//create list of ducks

List<Duck> ducks = new List<Duck>();

//upcast entire list to IEnumerable Bird

IEnumerable<Bird> upcastDucks = ducks;

List<Bird> birds = new List<Bird>();

//add our upcasted ducks to the bird list

birds.AddRange(upcastDucks);

Sorting with IComparable<T>

• We may want the ability to tell a list how to sort a class that

we have created.

• To sort a list, we can call the List.Sort() method. This method

will sort any type of class that implements the

IComparable<T> interface.

• The IComparable<T> interface has one method

CompareTo(<T>).

• So assuming we have a list of Duck objects, and we wanted

the ability to compare all of our Duck objects by their size.

Our Duck class would implement the IComparable<Duck>

interface and we would provide our implementation on what

criteria we want our ducks to be sorted against.

Sorting with IComparable<T>

• CompareTo() returns a 1 if the current duck is bigger than the

duck we are comparing against. If it returns a -1, if the current

duck is smaller than the duck we are comparing against

otherwise it returns a 0 to indicate they are the same size.

• Now we can call ducks.Sort() and they will be sorted based

on their size.

IComparer<T> interface

• We may want to create multiple ways in which we can sort

our ducks. So at runtime, we can pass in what way we want to

sort the ducks.

• To do this we can create a Comparer class that implements

the IComparer<T> interface.

• Then when we are calling the List.Sort() method, we can pass

our comparer class in as a parameter.

//assume we have a list of ducks

CompareDucksBySize comparer = new

CompareDucksBySize();

ducks.Sort(comparer);

printDucks(ducks);

CompareDucksBySize class

class CompareDucksBySize : IComparer<Duck>{

public int Compare(Duck x, Duck y){

//if Duck x is smaller than Duck Y return -1

if(x.Size < y.Size){

return - 1;

}

//if Duck x is bigger than Duck Y return 1

if(x.Size > y.Size){

return 1;

}

//If they are the same size return 0

return 0;

}

}

Object ToString()

• All objects in C# automatically inherit from the Object class.

The object class provides a few methods that can be

overridden by any subclass of Object.

• One of the most useful methods exposed is the ToString()

method. ToString() returns a string representation of an

object.

• This can be useful, as in our classes we can override the

ToString() method from the object class, to provide our own

string representation of each of our objects.

Object ToString() (continued)

• By default, the ToString() method just returns the name of the

class.

• In a Car class, we could override ToString() so that we could

instead return the type and year of the car when toString() is

invoked on a Car object.

public class Car{

private string nameOfCar;

private int year;

…

//Overriding ToString()

public override string ToString(){

return nameOfCar + " " + year;

}

}

Overloading Methods

• Overloading allows you to create multiple methods with the

same name in the same scope however they differ in their

method signatures.

public void Add(int number1, int number2)

public void Add(int number1, int number2, int number3)

public void Add(int number1, int number2, int number3,

int number4)

Overloading Constructors

• We can also overload constructors for an object, so that

perhaps you can have different ways of constructing the

object with different defaults.

public Student(int studentNumber)

public Student(int studentNumber, String studentName)

public Student(int studentNumber, String studentName,

double bursaryBalance)

Reading

Head First C#

• Build a House Exercise: pages 332 - 346

• Random Cards Exercise: page 375 - 379

• Birds List Exercise: pages 379 - 380

• Move Cards Exercise: pages 382 - 386

What’s to come next time

• Week 12

• This and That in C#

• Abstract classes

• Form Components

• Menus

• Navigation

• Toolbars

• Buttons