How did it go with the second challenge?

Let's walk through my solution.

To encapsulate the array of media type items inside of a class,

I started with adding a file named MediaLibrary.cs.

Then, I added the namespace, Treehouse.MediaLibrary.

And stubbed out the class, MediaLibrary.

In the MediaLibrary class I defined

a private array field of type

MediaType named, _items;.

Remember the private keyword makes this field only visible or

accessible to code within the MediaLiibrary class.

The underscore here at the beginning of the field name isn't required for

private fields, but it's a common naming convention.

Following this convention will make it easier to spot private fields in our code.

I then added a public constructor.

That accepts an array of MediaType items.

And then I used the items parameter to initialize the _items private field.

I completed my MediaLibrary class by adding a method named GetItemAt.

The method should accept an index of type int.

So int index, and it should have a return type, of MediaType.

Then, I just needed to return the item from the underscore items' private field

at the provided index.

So return _items[index].

Moving on to the program.cs file's main method.

I instantiated an instance of the MediaLibrary class,

var mediaLibrary = new MediaLibrary.

And I passed my existing collection

of items into the constructor,

new MediaType[ ] and { }.

Then I cut and pasted my items from here, into here.

Notice that I needed to add back the new keyword, and the array type in order for

my program to successfully compile.

This is necessary because the compiler can't infer what we're

trying to do here with our { } and MediaTypes of class instances.

Adding new MediaType[ ] makes it clear that we're initializing an array

of MediaType items.

Then, I updated the rest of my code to use the GetItemAt method

to retrieve items from the MediaLibrary.

So, DetectMediaType, so instead of items[0],

(mediaLibrary.GetItemAt).

We call it as a method because it is a method and pass in 0, the index for

the element we want to retrieve.

I'll copy this code to the clipboard and

paste it inside of these other method calls.

And change the indexes, 1, 2, 3, and 4.

Then do the same for the Display method calls.

And lastly, I saved the Program.cs file and compiled and ran my program.

And here, we can see the expected output in the console.

The addition of a MediaLibrary class fills a gap in our program

as we work towards a more functional version.

Let's look at an issue with our MediaLibrary GetItemAt method

implementation.

Let's make a call to the GetItemAt method and pass in an index for

an element that doesn't exist in our array of media type items.

I'll copy this line of code and paste it right below the other and

pass in five for the index.

Remember an index of 5 would map to the sixth element in our array.

Our array only contains five elements.

So if we compile and run our program, we'll receive a runtime exception.

Exception: Index was outside the bounds of the array.

And execution of our program stops without running the rest of our code in

the main method.

Okay, so for our third and last challenge in this practice session,

let's work to improve the situation.

In the MediaLibrary class,

update the GetItemAt() method to gracefully handle a bad index.

Use the array's linked property to determine if an index is available before

attempting to access it.

And return null if the provided index isn't available in the array of items.

And in the Program.cs file, update the Display and

DetectMediaType methods to handle when the item parameter has a null value.

And that's it for the third challenge.

We'll see you in a bit.