Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll
Preview
Start a free Courses trial
to watch this video
We can make our code easier to use by using collection interfaces whenever possible.
System.Collections.Generic.List
System.Collections.Generic Interfaces
For a review of interfaces in C#, check out this Treehouse course: Intermediate C#
Related Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign upRelated Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign up
If you take another look at
the documentation for the generic
0:00
list collection, you'll notice that it
implements a number of interfaces here.
0:03
Every collection type implements at
least the IEnumerable interface and
0:08
the ICollection interface.
0:14
These two interfaces define what
it means to be a collection.
0:16
As you can see, the list collection also
implements all of these other interfaces.
0:20
Including the IList interface,
which defines what it means to be a list.
0:26
Let's take a deeper look
at what it means for
0:31
a collection to implement
these interfaces.
0:33
And how we can use these interfaces to our
advantage when working with collections.
0:36
If you need a refresher on interfaces,
check the teacher's notes for
0:40
a link to a Treehouse course
they can get you up to speed.
0:43
To see a list of other interfaces
implemented by collections
0:47
in the System.Collections.Generic
name space
0:50
we need to take a look at
the documentation for that namespace.
0:53
You'll find a link to this
page in the teacher's notes.
0:56
Or you can click-on this link right here.
0:59
You wanna keep this
documentation page open for
1:02
the duration of the course because
we'll be referring back to it often.
1:05
Let's scroll down to
the section on interfaces.
1:08
Here's the IEnumerable interface.
1:13
IEnumerable is one of the interfaces
that all collections implement.
1:16
In order to use a foreach loop to
loop through items of a collection,
1:20
it must implement
the IEnumerable interface.
1:24
It exposes a single method
name to get an numerator.
1:27
We'll learn more about IEnumerators and
1:31
the IEnumerable interface
in a later course.
1:33
The ICollection interface is another
interface that all collections implement.
1:35
It exposes the Count property which tells
us how many items are in the collection.
1:40
It also defines Add, Clear,
Contains and the Remove methods.
1:45
The Contains method works just
like the index of method.
1:51
Only instead of returning the index of
the item it only returns true or false.
1:55
Not all collections can be
indexed into an array or a list.
2:00
But we can still use
the Contains method to determine
2:04
if an item is in the collection.
2:07
Notice that the ICollection interface also
inherits from the IEnumerable interface.
2:10
If you implement a collection on
your own you can just state that it
2:16
implements ICollection.
2:20
Listing IEnumerable is redundant.
2:22
The IList interface adds one property that
the ICollection interface doesn't have.
2:24
This is the Item property here.
2:31
This allows us to use the square
brackets to index into the list.
2:33
The IList interface also exposes
the IndexOf, Insert, and RemoveAt methods.
2:38
So these are the bare minimum methods and
properties that a list provides.
2:44
Of course as we've seen with lists classes
that implement the IList interface
2:49
can add additional methods.
2:54
As you can see there are many
other Collection interfaces that
2:55
the list doesn't implement.
2:59
We'll learn about these in
the rest of this course.
3:01
So why is it important
that developers know about
3:03
what each of these interfaces does?
3:06
It's important because we always wanna use
the interface whenever possible when we
3:08
specify what type of collection
a method takes as a parameter.
3:12
This gives the color of
the method the most flexibility
3:16
in what they pass into it.
3:20
I've created a class named SchoolRole.
3:21
That helps to manage all of
the students of a school.
3:24
Start a new workspace by clicking on the
button on this page to see these changes.
3:27
There is a method named AddStudents
that takes a list of students and
3:32
then adds all of the new students to the
list of students already in the school.
3:36
The way this method is written right now,
3:40
the color of this method would have
to pass the list collection type.
3:43
However, they might already have the
students they need to add in an array or
3:47
another type of collection.
3:52
They'd first have to convert their
collection to a list before it can be
3:53
passed to the AddStudents method.
3:57
However, the AddStudents method
3:59
doesn't need to use the full
functionality of a list.
4:01
It only needs the ability to loop
through the new students passed in and
4:05
add them to the SchoolRoll.
4:08
That's actually exactly what
the AddRange method does.
4:10
So we really only need to
accept an IEnumerable here.
4:14
So we can change List to IEnumerable.
4:19
This allows the caller of the AddStudents
method to pass in any type of collection.
4:24
Because all collections implement
the IEnumerable interface.
4:29
If the AddStudents method needed to see
how many new students were being added,
4:33
we could change IEnumerable
to ICollection.
4:38
This would allow us to
call the Count property.
4:44
Or if we needed to be able to index
into the student's collection
4:47
we could change IENumerable to IList.
4:50
However, by using a more complex
interface type we're limiting
4:54
what can be passed into
the AddStudents method.
4:58
So we'll keep this as IEnumerable.
5:00
You need to sign up for Treehouse in order to download course files.
Sign upYou need to sign up for Treehouse in order to set up Workspace
Sign up