Okay, we now have a repository, that's great, but

let's take another look at our design.

As we work on our project implementing this series and

artist controllers, we'll continue to add methods to our repository class.

Overtime, our repository can become bloated.

Also, our repository is currently concerned about persisting data for

more than one entity type, comic books and comic book artists.

We might think of our design is violating the single responsibility principle,

which states, that every class should have responsibility

over a single part of the functionality provided by your application.

Luckily for us, the solution to this problem is easy.

Instead of a single repository class, we can have multiple repository classes,

each focused on a single entity type.

Let's split out all of the repository methods that deal with comic books,

into its own repository class.

To start, let's add a class named ComicBooksRepository to the shared class

libraries date folder.

By default, classes use the internal access modifier, if one isn't specified.

That restricts access to this class to code within this project or assembly.

Adding a public access modifier,

will make this class accessible to code within the web app project.

Now, let's set up our database context instance.

At a private field of type Context named _context.

And a constructor that accepts a context instance, and

uses that the set the private field.

Remember, this is the same pattern that we used for the repository class,

which allows the controller to manage the lifetime of the context.

Now, we can select and cut the ComicBook related methods to the clipboard.

GetComicBooks, GetComicBook, AddComicBook, UpdateComicBook,

DeleteComicBook and ComicBookSeriesHasIssueNumber.

And paste those methods from the clipboard into the ComicBooksRepository class.

Let's also move over to ComicBookArtistRoleCombination method.

Looks like we've got some using directives to add.

For the namespaces, ComicBookShared.Models and

System.Data.Entity.

Now that we have a repository that's focused on comic books,

we can simplify our method names.

Consumers of this class will already know that they're working with comic books.

So we can remove any references to comic book from the method names.

For instance, we can change GetComicBooks to GetList,

And GetComicBook to simply Get.

And we can remove ComicBook from the CRUD method names.

For now, I'll leave the validation method names as they are.

Currently, we're instantiating an instance of the repository

in the BaseController class.

Doing this in the controller base class,

made the repository available to all of our controllers.

When you have a single repository class, this approach makes a lot of sense.

But when you have multiple focus repository classes, it's probably best to

allow each controller to instantiate the repositories that they need.

Given that, let's update the ComicBooksController to instantiate

an instance of our new ComicBooksRepository.

Add a private field for the repository.

And add a default constructor to instantiate an instance of the repository.

We need an instance of our database context to

pass into the ComicBooksRepository constructor.

In the BaseController class, the context is currently a private field.

We'll need to switch that over to be in a protected property, so

that it's accessible to the descendant controller classes.

And update any references to the private field to use the new property.

Back at the ComicBooksController, update the call to the ComicBooksRepository

constructor to pass in the base controller's context property.

Now we can update all of the bad repository references and method calls.

Repository.GetComicBooks becomes,

_comicBooksRepository, GetList.

Repository.GetComicBook becomes _comicBooksRepository get.

Repository.AddComicBook becomes _comicBooksRepository.Add.

Another call to Repository.GetComicBook to update.

Repository.UpdateComicBook becomes _comicBooksRepository.Update,

and another call to Repository.GetComicBook to update.

Repository.DeleteComicBook becomes _comicBooksRespository.Delete,

Repository.ComicBookSeriesHasIssueNumber becomes

_comicBookRepository.ComicBookSeriesHasIs- sueNumber.

And that fixes all of the build errors in the ComicBooksController.

Let's build the project by pressing Ctrl+Shift+B.

And the ComicBookArtistController has some build errors that we need to fix.

This controller will also need an instance on the ComicBook repository.

You might be tempted at this point to just move the ComicBooksRepository instance

into the BaseController.

But let's hold off on doing that.

I suspect that the series and

artist controllers won't need an instance of that repository.

So let's stick with our plan of letting each controller instantiate

the repositories that they need.

First, the private field.

Then, the default constructor.

And update the bad method calls

Repository.GetComicBook becomes

_comicBooksRepository.Get.

Once more, And

Repository.ComicBookHasArtistRoleCombina- tion

becomes _comicBook.Repository.ComicBookHasArtistR-

oleCombination.

And now the project is successfully building again.

In repository class, we have six methods left.

GetSeriesList, GetArtists, GetRoles, GetComicBookArtist,

AddComicBookArtist, and DeleteComicBookArtist.

Let's keep series, artist, and

role related methods in this class, at least for now.

Later on, when we have more than one method for

each of those entity types, we'll add a repository for those types.

But let's go ahead and

move the ComicBookArtist-related methods to a new repository class.

In fact, let's make that your next exercise.

Add a new repository class, move the GetComicBookArtist,

AddComicBookArtist, and DeleteComicBookArtist methods to it.

And update the ComicBookArtist controller as needed,

to get the project building again.

See you after the break.