How do it go with the third challenge?

Let's walk through my solution.

In the Program.cs file, I created a static method named detect media type and

to find the parameter of type media type named item.

I load the method right below the main method.

Static void DetectMediaType.

And for the parameter, it needs to be of type MediaType, and I'll name it item.

In the method body, I use the series of conditional statements and

the C# is operator to identify which particular media type subclass the item

parameter is an instance of.

So, if item, and then the is operator,

and then the type that we're testing for, Album.

Then a set of curly braces.

Then, else if item the is operator, then the Book type.

A set of curly braces, and

then another else if item is Movie.

And a final set of curly braces.

This series of conditionals will first check to see if the item parameter is

an Album.

And if that's not true, it'll check to see if the item is a Book, and

if that's not true, it'll check to see if the item is a Movie.

After determining the MediaType item subclass type,

I wrote a message to the console identifying that type.

So if the item is an Album,

I wrote Console.WriteLine item.Title,

+, and then a string literal is in album.

Copy that to the clipboard, then paste and paste.

All of this can stay the same here because item.Titles what

we need to output, but instead of is an album, say is a book.

Same thing down here for a movie.

We just need to change this to a movie.

And save the file.

Okay, so that completed my DetectMediaType method implementation,

then I needed to test my changes.

To do that, I passed each of my media type subclass instances into

a call to the detect media type method.

First, album1, so, DetectMediaType,

Then I pass album1 into the method call.

Let's copy that line of code and paste it four more times.

I'll pass album2 into the second call.

Album3 into the third, and then the fourth,

will get book and the fifth method call will get movie.

And lastly, I save the file, and I complied, and ran my program.

And here, we can see each MediaType item subtype written to the console.

Great work so far.

Now, let's take a look at a couple of shortcomings in our program.

First, let's see what happens if we pass null, or

an empty string as the argument for a media types title parameter.

Just after album3 here, I'll create a fourth album.

So var, album4 = new Album, and for the title,

I'll pass null instead of a value, then for

the artist name I'll say, Some Artist.

Then I'll create a fifth album, so album5,

= new Album, and this time, I'll pass an empty string.

And for the artist, I'll use Some Artist again.

Let's save the file, and compile, and run our program.

Looks like I forgot to call get display text on album4 and album5.

The compiler is telling us that we assigned a value to those variable but

we never used them.

So let's fix that problem, Right here.

Let's copy that line to the clipboard and paste it twice.

Then change album3 to album4, and album3 here to album5.

Save the file, And compile, and run the program.

And right here in the console, we can see that our program happily allows the null,

or empty string value in attempts to write the album's not

existent title to the console.

Let's look at another short coming.

In the detect MediaType method, let's comment out the last else if statement.

Then save, and compile, and run our changes.

We can see here that the three albums were identified.

And the book, but there's nothing displaying whatsoever for the movie.

This tells us, that the detect MediaType methods silently

fails to detect the media type for the movie subclass instance.

Ideally, the program would make it more apparent when it encounters either of

these situations, with a fourth and last challenge in this practice session.

Let's update our program to handle both of these unexpected situations in a more

robust manner.

In the MediaType.cs file, throw an exception in the MediaType class

constructor if the title parameter is set to null or an empty string.

Set the exceptions message to, A media type must have a title.

In the Program.cs file, throw an exception in the DetectMediaType helper

method when an unexpected media type is encountered.

Set the exception's message to Unexpected media subtype encountered.

Then, to finish this challenge up,

wrap the code in the Main method in a try/catch statement.

Define a parameter in the catch clause, in order to get a reference to the caught

exception, write the exception's Message property to the console.

And that's it for the fourth challenge.

See you in a bit.