If you take another look at the documentation for the generic

list collection, you'll notice that it implements a number of interfaces here.

Every collection type implements at least the IEnumerable interface and

the ICollection interface.

These two interfaces define what it means to be a collection.

As you can see, the list collection also implements all of these other interfaces.

Including the IList interface, which defines what it means to be a list.

Let's take a deeper look at what it means for

a collection to implement these interfaces.

And how we can use these interfaces to our advantage when working with collections.

If you need a refresher on interfaces, check the teacher's notes for

a link to a Treehouse course they can get you up to speed.

To see a list of other interfaces implemented by collections

in the System.Collections.Generic name space

we need to take a look at the documentation for that namespace.

You'll find a link to this page in the teacher's notes.

Or you can click-on this link right here.

You wanna keep this documentation page open for

the duration of the course because we'll be referring back to it often.

Let's scroll down to the section on interfaces.

Here's the IEnumerable interface.

IEnumerable is one of the interfaces that all collections implement.

In order to use a foreach loop to loop through items of a collection,

it must implement the IEnumerable interface.

It exposes a single method name to get an numerator.

We'll learn more about IEnumerators and

the IEnumerable interface in a later course.

The ICollection interface is another interface that all collections implement.

It exposes the Count property which tells us how many items are in the collection.

It also defines Add, Clear, Contains and the Remove methods.

The Contains method works just like the index of method.

Only instead of returning the index of the item it only returns true or false.

Not all collections can be indexed into an array or a list.

But we can still use the Contains method to determine

if an item is in the collection.

Notice that the ICollection interface also inherits from the IEnumerable interface.

If you implement a collection on your own you can just state that it

implements ICollection.

Listing IEnumerable is redundant.

The IList interface adds one property that the ICollection interface doesn't have.

This is the Item property here.

This allows us to use the square brackets to index into the list.

The IList interface also exposes the IndexOf, Insert, and RemoveAt methods.

So these are the bare minimum methods and properties that a list provides.

Of course as we've seen with lists classes that implement the IList interface

can add additional methods.

As you can see there are many other Collection interfaces that

the list doesn't implement.

We'll learn about these in the rest of this course.

So why is it important that developers know about

what each of these interfaces does?

It's important because we always wanna use the interface whenever possible when we

specify what type of collection a method takes as a parameter.

This gives the color of the method the most flexibility

in what they pass into it.

I've created a class named SchoolRole.

That helps to manage all of the students of a school.

Start a new workspace by clicking on the button on this page to see these changes.

There is a method named AddStudents that takes a list of students and

then adds all of the new students to the list of students already in the school.

The way this method is written right now,

the color of this method would have to pass the list collection type.

However, they might already have the students they need to add in an array or

another type of collection.

They'd first have to convert their collection to a list before it can be

passed to the AddStudents method.

However, the AddStudents method

doesn't need to use the full functionality of a list.

It only needs the ability to loop through the new students passed in and

add them to the SchoolRoll.

That's actually exactly what the AddRange method does.

So we really only need to accept an IEnumerable here.

So we can change List to IEnumerable.

This allows the caller of the AddStudents method to pass in any type of collection.

Because all collections implement the IEnumerable interface.

If the AddStudents method needed to see how many new students were being added,

we could change IEnumerable to ICollection.

This would allow us to call the Count property.

Or if we needed to be able to index into the student's collection

we could change IENumerable to IList.

However, by using a more complex interface type we're limiting

what can be passed into the AddStudents method.

So we'll keep this as IEnumerable.