ASP.NET Core Web App チュートリアル - パート1 (ASP.NET Core Web App Tutorial - Part 1)

字幕表動画を再生する

Hey guys, Wes here. So, I don't know about you guys, but I think the first place. I ever used the internet was at the library
so I just finished designing a
library management system in ASP.NET Core MVC
and I thought it would be kind of fun to
Make a series of videos documenting that project so you guys could follow along and we could do some full stack development
We're going to do everything from setting up and designing the database
to implementing the MVC pattern and then finally playing around with some front-end stuff like DataTables (.js)
and maybe some Material Design and Bootstrap
So yeah, the project was kind of fun, and I thought it might be something that you guys would be interested in checking out
So yeah, let's take a look
Okay, so let's take a look at the software we'll be building over the course of the next several videos
So we have here an integrated library system for a fictional library called Lake View
So an integrative library system also sometimes called a library management system is the software that a library uses to
to lend its Assets and manage its assets
As they're lent out to various patrons who might sign up for a library card
within that system. So - the library is going to control
You know it's books, magazines - things like that
so it's going to need to manage all of its inventory and
sort of control, you know, how it lends out to its various patrons and to keep track of what patrons have what assets and
what patrons have certain items on hold, for instance.
It's also going to want to track the different branches that belong to that library, so if you live,
for example, in a larger city or region, then your library system might consist of multiple branches
Let's take a look first of all at our library catalog
So you'll see here that we just have a list of assets very simply in a table here
And so we're going to have like the title of whatever the past that is in this case. We'll have a lot of books
The author or director, and then a do we call number, so if the library's going to do a decimal system
This is just a way that they index their books yeah, we can see that the books all have covers
And if they don't we have no cover available icon here
So if we click on one of the books we get taken to a detail page here
so we have a lot more Metadata on this book that we can see so we've got an iSbn for instance a
Call number again. This is the Dewey call number the cost of this asset
What it is so if it's a book or a video or anything?
Its last location so the answers will be associated with a particular Branch
Some checkout history, so in other words
what patrons have checked out this item in the past and over what period of time and
Then also a list of current holds so look at what that means in here in a second
So let's say I wanted to check this book out so I just click here
and then we supply a library card id to which we to check out the book and
now we can see that the book is no longer available, but it has been checked out by this patron and
We can see now that we have a new checkout history started in the table here as well
So the book hasn't been returned yet, but it was checked out this time on this date
So now let's say that I'd like to check the book out, but I'm another patron
and of course it's not available for checkout yet, but I can place a hold will click place hold here and
Let's say we'll put the new customers
library card Id here and we'll place a hold and
So now we'll see that this patron has a hold on the item and again other customers can continue placing
Hold and so we'll basically have a queue here of hold so that when our
Customer tomas here checks the item back in
it gets checked out automatically to the first person who had a hold on it a new checkout history record is created and
The Q obviously drops one of the patrons so again if this is checked in by Mary Lee
Is now automatically checked out and if you checked it in
The book is back to being available for checkout. We can also very simply mark it mark the item is lost
Not at which point. It can't be checked out can Margaret sound again
So that's our kind of simple check-in checkout system
To go back home and we click patrons now
We can see how we can manage different patrons that are in our system, so we can see their overdue fees
What library cards are associated with what library branch there so sid live if we click on one of the customers here?
We can see their name address
It's an explanation that they might supply when they sign up for a library card
as well as the current items they have checked out and any assets that they have placed a hold on we can also see if
The customer has any fees on their account
It will show up and read on their profile page here
So we can see that this customer has fees due and then so we can base some logic on this and say
Like if the customer has a certain amount of seeds on their account
They might not be able to check out a book or a video just a small other feature we have here some other information
We have on our patron object and finally if we take a look over at our branches page. We have another list view here
Where we have some data about the branch how many patrons are associated with a number of assets that are associated with it?
Whether or not it is open
And if we click on it, we can see a picture
It's scheduled so the dates between which the branch is open
the Total value of the Assets owned by the Branch and some more data so like the description and
some sort of profile data on this particular branch and so each of the branches will have its own sort of profile page and
The specific Data associated with it
So yeah, this is our simple integrated library system or library management system, and it's kind of fun to build it's pretty straightforward application
It's not very large
but it's actually it would be a fairly decent starting point for an
Actual system that managed sort of any type of inventory or any type of check-in checkout system. Where you have patrons?
Various locations and various assets to control so I think it's kind of a good general purpose project
Particularly if you are interested in learning about the MVC pattern or just diving into some net
okay, so I have visual Studio open here and
So we'll go ahead and create a new project. So just file new project and
we're going to create an asp.net core web application and
I'm just going to call it library, and I'll place this in a projects directory that I have here
and
We'll make sure that it creates a new git repo and creates a directory for the solution
So we'll select ok and it's going to ask us if we'd like to use a template and we're going to use the web
application template which is going to allow us to create an asp.net core application with
MVC
Okay, so you can see that by default here with this template
we have a project structure in place already, and if you've developed in asp.net before this may look a little bit different to you if
you're coming to dotnet core for the first time so
Something that you'll notice here. Is that we have a wwe?
And that's going to contain all of our static files so csS images Javascript
Third-Party libraries, and you can see that the template has brought in jquery and bootstrap, and yeah
So we can actually use this directory to serve up our static files
When it comes time to load some of those a little bit later, and then we have directories for our
controllers and views and
so the template has provided us with the home controller and
Some views for the home controller here as well as some shared views so a layout and a narrow page here
So the layout that's the htML. This is actually going to be shared by all the other views in our system, and so you'll see
That we are implementing razr Syntax here
So anytime you see a spiral and then some keyword here, we're going to be using new razor
templating engine and
So that we can dynamically render htML on a page in these Cs. HtML files so you'll notice that?
Towards the middle of the page here after we define the head and the body tags and we have a navbar
Inside of this dIV with the class container body content
We have this render body method that's being called after the spiral here
And so this is actually where all of our views will be rendered by default in our application. So very quickly
we'll take a look at the application that the template has provided us with and we can just fire up the
Browser clicking the iis Express button up here with a play button you
Can also hit F5 as long as the library is set to your start up project?
Okay, so the browser is going to pop up here, and I'll just maximize it
It may take a little bit longer to fire up the application if this is the first time that it's being built and it's worth
noting that unlike in some scripting languages of you're familiar with
Developing web applications in Django using python or in a particular
Javascript framework if you have a small node server running
We're actually going to need to stop and start or sort of anytime we work on
Compiled codes of things like code that's in our controllers and models, okay?
So we have the application up here
And you can see that it has created a simple home page for us that has a sort of carousel slider here
And then we have a nav bar up top here with home about and contact link
So if we click on these and notice that pages are getting rendered for us if you take a look at the url in
A browser you can see that all the links that we click on here are relative to this home path
so home is the controller that our application is using in this particular case and
Then the action will be the second part of our path here
so home slash about is going to look in the home controller for an about action and
home Slash contact is going to be looking in the home controller for a contact action and
Then our Index page looks like it's rendering
Probably the index section on the home controller by default when we have nothing in our route here
So let's take a look at where that's configured, so I'm just going to close the browser and hit stop and we'll come down here
to
Will close our view and controller folders, and we'll come down here to the startup that's es file
Which contains our startup class?
and
this class contains a constructor and two methods the configure services method and
configure method if we look inside the configure method you can see where we are actually telling the application how to
do its routing so we have a default route here where the controller is going to be set to home and
then we'll have slash index slash and optional id that might get passed years you can imagine that we might have for example like a
detail view where if we had say like an iMages controller and then select images and then
Tale action where we were going to pass the id of a particular image?
Then we could go to like a detail page for that image
Let's talk a little bit about this startup class as a whole so again
if you've developed an asp.net application in the past you may be familiar with
Seeing like a ab dot config file and a global
Sx file here in your project structure everything now is going to be handled inside of our startup dot CS class and
You'll notice that in the constructor for this class
We are actually going to be building all the configuration for this application
using this configuration builder class and
So all the configuration is going to be stored in a series of JSon files that might contain any
Configurations that we set for application
And so we'll have pairs of keys and values in
Json files that will represent the various configuration values that we might need to use and
If we have new Json files that we'd like to add to our application. We can actually
Just chain another adjacent file method here onto our configuration builder to apply those configurations
So that's pretty straightforward note also that we can add environment variables to our configuration builder
which is kind of nice because we could store things like database passwords Connection strings or any other type of
Configuration that might be particularly an environment that our application is deployed to
Those can be set here and they can actually be set last so that they'll overwrite anything
That is set in the JSon files that live with the application itself
so this is how we'll build out the configuration for our application and
we'll go to the app settings that JSon file in a little bit when we
Specify the Connection string to the database that we'll be using
Okay, so if we come down now to the configure services method you can see that. We have a comment here
It says this method gets called by the runtime
Use this method to add services to the container so dotnet core is
leveraging the concept of dependency injection here
And so you'll see that as we create various services that are going to handle working with our data sources
Okay
working with a database or maybe some response from a remote api
What have you will register all those services here in our configure services method?
We'll go through an example of that shortly as we create a services layer for this application
And if you're wondering about sort of what I mean when I say services, they are essentially just objects that have a particular
functionality for other parts of our application
and then we can actually inject those services and so
Say like our controllers might require us if we have a controller for say our books
We might have a book controller that will create later
We'll have a book service that we can actually
Inject into our book controller so that it can retrieve data about the books we have coming from any particular Data source that we might
Want to implement in our case
We'll be using a database
But we'll construct it in such a way that the controller simply asks for what it needs via this
Service that will create that'll be nice because we won't be doing things like throwing a DB
Context directly inside of our controller any part of the application that wants access to the database
Will be instead injecting this service ok and then if we look down again at the configure method
This is where we saw our use MVC called here on the app all this is
Middleware so middleware is going to be the components which handle hTTP requests and which produce an HTTP response?
So we'll have things like use static files called here
And will control what types of air pages are shown for instance depending on what type of environment?
We're running in and so the configure method in general is setting up
What would be called our request pipeline ok we won't actually have to do much or if anything in our consider?
method for this application
But we will be revisiting the configure services method as we go through and add services to our project ok so now
We'll take a look at our program that CSV file which contains our program class
This is the actual entry point for our applications
so you see that this is where our main method gets called and this is where we're actually going to run our web host and
So similar to a configuration builder we have a web host builder here
Where we will be setting up the web host that we want to run when our application?
Starts, so Kestrel is a lightweight server, and you can see we have I is
used as well, which is a little bit more of a
Full-fledged server and you can see that
we're going to use the startup class where we set up the configuration and middleware for our application and
Eventually we call build and then once the web host is built we call run on it
And so that's basically how our application gets bootstrapped all right the last thing we'll look at before we
Get into writing a little bit of code is if we look at the app settings that JSon file?
You'll note that. This is part of the configuration files that we are building for application the only key that we have in here
Right now is one for logging here, but very shortly
We'll add a connection string to the database that we'll want to use
I think now be a good time to start thinking about our data and so what we'll do is
go ahead and right-click on our solution, and we're going to add a new project and
we're just going to call it library data, and we needed to actually be a
class library, so just going to hold a bunch of C-Sharp files for us, so we'll say ok and
This data class library is where we're going to implement any framework core
So I'm going to right click here and select manage and you get packages
We're going to click browse here
So we can browse online and we're going to add Microsoft got entity framework core
and
So you want to make sure that you select the option that says at any framework core and not a previous version of any framework?
So we'll go ahead and install this this is going to be our our orm that's going to be used to
Essentially map the data from our entity models which are just plain C
sharp objects to our data source which in our case is going to be a
Sequel database using Microsoft sequel server and so to use Microsoft sequel server within a framework core. We need to also install
Microsoft at any framework sequel server, so I'll go ahead and install that it's worth noting that with any framework core
Microsoft now supports the use of
other types of databases besides server and apparently even non-relational databases
So I assume that means sort of document based databases like no sequel databases
Maybe like Mongodb or something are supported although
I don't have any experience implementing those in a dotnet project yet
But if anyone else does I would be interested in seeing it implemented, okay the last thing that we'll add here is
Microsoft any Framework tools
And this is going to allow us to use the package manager console to do database migrations
So in any framework core is exclusively a code first o rm meaning that
We're actually going to write all of our
entity classes in Code first then any framework is going to
look at the models that we created compare them to some database that will tell it to connect to and
Make any changes to that sequel database is actually like
creating tables from the class names and creating columns from the property names and basically generating a
Complete sequel database just by looking at the structure and content of our C-sharp classes, okay awesome
So now we have a library data class library that's set up with entity framework and the first thing that we need to do to
Work with entity framework is to create a class that's going to inherit from any frameworks DB context and so DB context is
essentially the link that exists between
Your enemy classes and the database so as I said we'll be writing all of our
database models if you will our entity models in C-sharp classes and entity framework needs a way to
make that mapping and so we need to create that particular DB context classes that will be responsible for
interacting with that data as a C
type object
So let's just go ahead and do it and we'll take a look at what it looks like so
By default for some reason when we create a new class library we get this class 1 dot Cs. File in here
so we're just going to rename this so right click and rename and I'm going to call this library context and
We'll say yes to rename references in the code, so it's going to say
public class library context here and so as I said we need to actually inherit from
the dbContext
Abstract base class that is provided by any framework, so if you hit control period Over dBContext
You'll see that you can implement this using that we need to include at the top floor file here, okay?
And now we're just going to create a constructor for this class
So it's a public library context and we're going to pass it DB contact options
so we can just call options and
Then we'll take these options and pass them to the base class constructor. So just do that. I think base options
and
It's really as simple as that in terms of just setting this class up, but the important thing here
Is that we're going to have a series of what are called DB sets?
And so it'll look something like this. It'll say Bb set and then we're going to specify the entity object here
so for instance if we have a patron object, and we'll use on property accessories -
Okay, so we don't have a patron object yet
but I just wanted to show you that this is how the library context will be structured and so our table is going to
map to our Patron object and then the
Properties on that patron object will map to the columns in that patrons table
So let's go ahead and actually create a patron object what I'll do actually is
right click on
Library Data, and we'll add a folder for all of our domain models here, so we'll call it models and in a moment
I'll go over all the different objects
I think we'll need to consider when creating an integrated library system, but for sure we'll need something to represent
The Patrons and so we'll just use that as our first example here
So I'm going to do is add a class, and it's just going to be called
Patron and
We'll make it public so that it can be accessed by
our library context and so the way this is going to work is we're just going to make this a
Plain Old C
Sharp object and so on each one of our classes here
We'll want to specify an id that's going to be mapped to the primary key on our sequel table
Then say the Patron will probably have a first and last name
And then maybe a simple field for an address probably like a telephone number which you could store
As a string or as a number, and then in fact the patron will have some other objects that are associated with it
so if you think of like foreign keys in a database
Will have some objects like say a library card which were which will create a little bit later
So we'll actually be able to do things like this as well
so say we have some library card object and any framework is actually going to be able to map our patron object then to a
library card
Object using a foreign key on say like the ID property of this library card object when it's created
So look at that in a little bit and in fact we can also called virtual on this which will allow us to lazy load
That library card object so any time we pull an instance of patron
We don't necessarily want all of the data that's on library library card to be loaded at that time
But we'll cover all of that in a little bit. I'm just going to comment this line out for now
So you want to make sure again that?
You have installed your microsoft and any framework or tools and sequel server
nuget packages
before moving on to this section
so if those aren't installed in this next part
isn't going to work what we'll do is head over to our app settings a jSon file and
We're going to add a new Key here called Connection strings
So it's going to be a new object here, and we can give it a name, so I'm just going to call this one
Highbury connection, and then the string should look something like this, so we'll have say server equal to
local Db xs backslash Microsoft sequel
Local DB and so first of all this local DB will exist if you have Microsoft local BB installed
and
Once it's installed. You should be able to confirm it at the command line
And I'll show you how here's I'm just going to open up command line, and if you just type in equal local DB
so
You should see a series of databases that will be running on your computer
If you don't see em f's equal local DB running here
You should be able to type
Sequel local DB
start and then LS sequel local DB and that will start an instance of
Ms. Sequel local DB on your computer it first amazed me to stop and delete the instance you would call
sequel local DB stop and the sequel local DB and
Delete but of course you want to be very careful if you are running either of those commands so back to our connection string here
we now just need to specify a
Database name so this can be whatever you like
But whatever you type in here is what any framework will create when when we do our first migration here?
So let's just call it like library
deb for instance
Then it's going to include two more parts in our connection string here the first is claude trusted connection
True that just going to allow us to use our windows authentication to connect that database and the second part is multiple
active result set
equal to true
Okay, so we'll just save that
And before I forget let's go back to our library contacts, and we want to make sure that we
Include the models that we created here, so I'm going to control period Here
And then make sure that we're using this library data models namespace so that we have access to this patron object
I'm actually going to control period Up here and remove unnecessary things as well save this file
Okay, and now to get any framework talking to our database
we need to actually add this library context to our services collection, so
In order to add a DB context we need to add entity framework
to our library
project, so I'm going to go ahead and
right click on library manage nuget packages, and we need to find any framework or
So I'm going to like this and we'll install it here
This is going to give us access to that ad dbContext method and now that entity framework core is installed
we'll also need to install entity framework or
sequel server
And I'll accept so we have these
New get packages installed in both of all in both our data layer as well as the web layer
So let's take a look at our dependencies and then under new Gap
Okay, so I can see that it has been installed here
I'm going to go ahead now and
We'll go into our
Startup class and if we come down to the configure services method as I said, we'll be revisiting
This method as we want to include services for application to use
we need to
Call add DB context on our service collection now, so add. VB
Context and we're going to use the library
Library context that we created earlier as the type so to do that
I actually need to reference the library Data project in the web project
I have here so we're going to right click here, and I'm going to go to add reference and
We'll add a reference to our library data project from our solution. So say ok this will allow me to
control period On library context here and
Pull in the using library Data statement at the top of our file and here
I'm just going to pass a lambda function that will call options options dot
Use sequel server
And doesn't click we're getting intelligence on this
So let's go to the top of the file here and manually type in new things
Microsoft at any Framework or
and
Ok so that gives us access to the use sequel server method here, and I'm going to put the land on one line down
So we can read it all and then we need to pass the use sequel server our
Connection string and we can get that again through this configuration
Object that we had built and we'll call get connection string there
and
We just need to specify the name of the connection string that we just added to our
app settings that Json which if you recall was just library connection
So we're going to go ahead and throw that here, and we're missing a single parens
okay, so you can see I feel like that structures really nicely just having this configuration object that gets built here and
Then being able to call a single method get to get connection string
Passing that the key from our JSon object
And this is going to provide entity framework with the context that we are creating for our library application
So now let's run our first database migration and create our first database
so database migration is
essentially just a way of moving a database schema from one state to another and so anytime we make
Changes to our schema which would be say like adding a table or dropping a table or altering some columns and so
Migrations make that possible, so let's take a look at what happens when we create our first migration
So if you head down to the package manager console here and set your default project to library data
first Command, we'll run is
Add - migration and we'll say initial migration
and we just need to put that in quotes, so
I'll hit return and the output we get is simply a remark that if we'd like to undo this action use remove migration
But more importantly we see a new folder that was created in our library Data project called migrations
And it contains this initial migration
That Cs. File, so this is just a C-Sharp file
That is going to go to migration for us for our sequel database, so you can see in this case
It's actually going to create our patrons table for us and create columns
Corresponding to all the properties that are on our patrons domain object, okay?
So if we want to commit this to the database if you will we just need to say update - database
and
The first time that you run this since we don't have a database created. It's going to take just extra seconds
but what any framework is doing that is it's going out you are using our connection train going out to an instance of
Local DB and saying I don't have a database called library' Dev here
I'm going to go ahead and create one, and then I'm going to create those table patrons because it doesn't exist either
Okay, and so you see that when it's complete you just get done here on the console now
If we go to the sequel server object explorer in visual studio. You don't see this you can click view
sequel server object explorer here, and if we look under
Local Db /Ms sequel local DB and then under databases in my case
I have two databases here once the demo that we looked at earlier
but in our library underscore Dev database and then in the tables folder you can see that we have a
Patrons table
And the patrons table contains columns for all the properties that were on our domain object
And so it looks like this migration was successful. So if you've gotten this far already, I would say
Congratulations, because you now basically have a database using code first
hooked up to your
Application and so we can now begin to think about how we're going to
Construct the Data that will represent the various objects that we'll need to use in our
Integrated library system one thing
I would highly suggest doing is if you don't have Microsoft sequel server management studio installed
I would go ahead and install that and if you open it up, it'll look like this
It will ask you when you first open it to connect to a particular server name. We'll be able to use windows authentication
You'll just need to type in parens local DB. And then backslash and that sequel locally be and then you'll be able to click connect
and if you don't see your database in the list of databases here just click this refresh button and
Then re Expand the databases folder, and you should see it here now, so I see library Dev
Now if we right-click on this and select new query
Now we can actually run raw sequel against the bass that we created
So for instance although we don't have any did it and now I can select star from Patrons
If I run this I can see an empty table here and again now
You can see the columns that map to our C. Sharp object that we created earlier
okay, so
fantastic so far now
I'd like to take a short step back and let's just think for a minute about
The objects that will need to be represented in an integrative library system
so if we think about a library
It's basically a place where people go to
checkout media yet books or video or magazines and as a library what I might want to do is manage the
Patrons that come to my library to check out those assets and the assets
themselves
So I can see you know where they're going if you help frequently they're getting checked out whether or not they've been lost
Whether or not they are being returned late, and I need to charge a particular Patron some fees
And then I also might want to get some understanding of the various branches that are in my system
So what library buildings contain what assets what Patrons are?
associated with what library branches and so you can see we kind of have a
system of objects that all kind of interact together here and on top of that we need to also develop some type of
Checking in and checking out system
So that we can actually manage the flow of our assets
And so I think it's fairly safe to assume that we should create objects that represent our library assets
Our patrons and our branches let's think first about what a library asset
Object would look like well
We would know that it would have some data associated with it like a title and author the year
It was published its cost and any number of other sort of Metadata that are essentially properties on a library asset
But we also need to think about how that asset relates to things like our branch locations in other words
Where's that asset typically stored when it's checked in?
And then we also need to think about its state in terms of like if it's currently checked out by a patron if it's lost
At time did all these things occur so on one hand we have some sort of Metadata
That's directly associated with this object and on the other we have some data that will represent this objects
Relationship or state with other objects in our system, okay?
And so let's think about the patron now well similar to the library app that the Patron will have some Metadata if you will
sort of like person's name and their address or telephone number
Anything that sort of describes this patron and then on the other hand we have data associated with
This Patrons relationship to other objects in our database
So we can imagine this patron having a library card which has an ID
And maybe a home library branch that this patron belongs to if you will and then finally our third
Big object in the system will be a library branch and similarly the properties that might describe that library branch include its name telephone number
And address and some the data that it relates to might be the total cost of assets that it controls or stores the total number
Of its patrons and finally we should think about a checkout system
So we need to associate an asset with a library card
so we're going to associate assets with library cards as opposed to patrons so that we have one layer of
removal if you will from our patrons with the items that they're checking out that's going to be represented with this library card object and
Then we'll want to define a time that an asset was checked out at a time that the essay was due for instance and so
Now let's think about this library card object so a library card will have a one-To-one relationship with a patron
And in the sense it will represent a sort of layer of abstraction
Between the ss
That a patron checked out and the patron him or herself the library card will also be used as the object that contains information about
overdue fees and
Assets that are checked out to the particular patron who has the relationship with the card, okay?
And then finally we'll have some additional
Functionality to incorporate this idea of holds, and we'll talk about that in more detail as we develop that feature
But that's going to allow patrons to put holds on items while they're checked out by other Patrons
Such that when the patron who has the item checked out?
Turns it. It will automatically get checked out to the patron with the earliest hold
And then we'll have a concept of checkout history, so we'll keep an audit of every checkout that occurs in the system
and
we'll have a concept of assets status and so that will be a table of static data that just
Contains all the different statuses that the library SI could have so like checked out checked in lost
ETC alright awesome
So now that we have a kind of big picture view of what our?
Objects will be let's go ahead and create some domain models for them
And then we can run a new database migration so that we have a database schema created for us
So I'm going to go back to the code and then I close the sequel server object explorer for now
and I'm also going to minimize our migrations folder and
just rearrange our
Layout a little bit here to make it easier to see and what I'd like to do is in our models directory
I'm just going to create classes for all the different objects that we just talked about so I'm going to click add new class and
For Brevity I'm going to create a class for each of the objects here
And then we'll look at the properties on each of them in a moment and after all the classes will are created
We'll look at them individually
Okay, so I've gone ahead and created all of our entity models here in separate classes that we'll need to use for our application notice
That I can have supply this required attribute on any of the attributes that I want to specify as non-null in our sequel database
So notice that I have a class book
Which is inheriting from an abstract base class library asset?
Which has a model in our models folder and the reason I'm doing this is because
you can
Imagine our library will control a number of different types of things which still have many of the same properties that are relevant to us
so anything that a library will provide as an asset will have a title a year the
Status which we'll take a look at in a minute the cost an image that we can use for presentation in our views
May be a number of copies
And it will be associated with a library branch
so notice that I have this public virtual library Branch property on our library asset class and
so this is going to create a sort of foreign key relationship between
Anything that is a library asset and a particular library Branch
And so when we look at the sequel table after we do our migration. We'll see a library Branch
Id on the library asset table now
You may be wondering also how this inheritance is going to work?
So we can actually set it up to work a number of different ways by default
I think entity framework core is going to implement
what's called a table Hierarchy strategy which just means that it's going to
create a single table called library asset and so any concrete class that inherits from
Library asset will be represented using a column called discriminator on the library asset table now
Now to be quite honest with you, that's not necessarily my favorite way to represent data
I don't think it's necessarily bad, but in any framework
We can't actually directly select on that discriminator column
It can make it a little bit tricky to think about how to use these concrete classes that inherit from the abstract type
but it is nice on the other hand that all the
Assets the library controls will be contained in a single table and not spread out across
any number of any arbitrary number of other tables like book and video or
Periodical or whatever other types that you might include in your system, so we're going to work with it
And it's going to work out. Just fine next I've got a branch hours class and this is actually going to be used to
Store the hours that are various branches are opened, and so on like say a branch details page. We'll be able to
ControL what is shown per Branch?
By something we store in the database
Which is a lot nicer than updating like some static HtML
And so of course we are going to need an iD column and then we're going to need the library branch that each
Set of hours are associated with and then we'll have a column for day of week and an opening close time and so each Branch
Will have up to seven rows representing each day of the week and then an open and close time for each of those days
next we look at the checkout table and
Each of our checkout objects as mentioned when we were thinking about the sort of model structure of our application
We'll have a library asset, so in other words
they like a book and a library card which again has a one-to-one relationship with the Patron and
then we'll have a day time object represent the boe fee sense and
Until dates which will let us know when an item was checked out
And when it was due then we'll have a simple checkout history table
Which will be a sort of audit table that again just shows when an item was checked out
And when it was checked in We can make the day time Column explicit explicitly knowable here with a question mark
then we'll have a hold table and the hold is going to represent the library asset for which a hold has been requested a
library card which will represent the library card that has requested the hold and
Then a date that the hold was placed and this will allow us to set up a sort of cue structure
Such that for any library asset. We have a series of library cards that we know
requested the whole at a certain date and then so if we order that by
the day time we have this cue where we can see who came first and
Thus who we owe the library asset to when it's checked in ok and then?
Finally down to the library asset class
Which is sort of one of the core classes of our application?
And you'll see that I have defined it as an abstract class which means that we will need it to be inherited by these concrete
Child classes like book and end video which we'll see in a minute here, but again
It's going to contain all the properties that any asset controllable by the library would have
And then we have a library branch and you'll notice I have some other attributes here on these properties
In this case I can define a maximum string length and some error message
I'm going to take the error message out
But I put here just to show you how you can pass an error message to this string length, attribute
okay, so we've got an address telephone number description and
open date in other words say when the branch was founded and
then I have a collection of
Patrons and a collection of assets that belong to that library and then we can store an image url
Which will contain an image that we can put on the branch detail page
and we've got the library card asset which again is another simple class which contains the overdue fees a
Created date and a collection of checkouts that are associated with that card you have the patron class which has all the patrons
Metadata and what I'll do now is uncomment our virtual library card property and
create a library Branch property on it -
we'll call that home library Branch and
If you want to put attributes to specify like a max length on any of these other
Properties you may want to implement that as well, then we've got our status table
which again is just some static data that will represent the name in the description of the various states that our assets can have and
Then finally I've got this small video class. Which is just under another type of asset
So in our library asset discriminator Column. We'll have books and videos
If you're creating this app for yourself you might also consider adding
Concrete classes for say like Magazines or newspapers or again any other type of asset that your library branch might to offer?
Okay, now that we've added all of our models
Let's go back into our context and we need to add DV sets for each of these tables
and
Now let's go ahead and run our next migration. So we'll say add - migration, and we'll call it
add initial entity models
and
You can see that our migration gets created this time
It's going to be quite large compared to the initial migration that we ran and we'll just go ahead and type in update - database
Okay, and it says done
So it means that we have actually successfully created a database schema to represent all the data that we'll need to
control in our system, and that's a really huge first step towards developing our application, so
Congratulations again if you have made it this far
And now what we'll cover in the next video is how we'll write some services that will get used by our
Controllers in our web application to query and add an update and work with all the data that we'll store in our database
we'll also provide some scripts to
populate the database with a bunch of sample data so that it's a little bit more interesting to work with as we develop and
From there, we'll actually implement our view models and implement the Model view controller
design Pattern in our web app, so this video was all about Data and
Architecture and kind of thinking about how we're going to structure our application
How we're going to structure the data that doesn't always make for the most exciting code
but it is probably the most important step and starting a new project is just stepping back and
Taking it a little bit slow at first and kind of thinking about okay
How is this all going to fit together? And how is it going to work?
And it makes all the difference on slightly larger projects to take the time and do that upfront
Makes your life a whole lot easier each step of the way thereafter, so thanks for watching this video
I hope you enjoyed it stay tuned for the next video when we dive deep into creating services and laying out our
Model-View-controller design
Pattern if you liked this video. I'd really appreciate it if you liked and subscribe, and I'll see you next time