ASP.Net MVC Quick Start
4.4 (1,471 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
16,709 students enrolled
Wishlisted Wishlist

Please confirm that you want to add ASP.Net MVC Quick Start to your Wishlist.

Add to Wishlist

ASP.Net MVC Quick Start

Build a basic CRUD (Create, Read, Update, Delete) web application with MVC and the Entity Framework in a weekend.
4.4 (1,471 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
16,709 students enrolled
Created by Brian Gorman
Last updated 8/2017
English [Auto-generated]
Price: $80
30-Day Money-Back Guarantee
  • 5.5 hours on-demand video
  • 10 Articles
  • 13 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Understand the major pieces of the Microsoft ASP.Net Framework
  • Discuss the differences between Models, Views, and Controllers
  • Understand how to use the code-first approach to generating a database using Entity Framework
  • Have the tools to setup and host a basic CRUD Web Application online
  • Have a basic understanding of working with Git, BitBucket, and AppHarbor
View Curriculum
  • You should at least be a little familiar with Web Programming in HTML, javascript, and CSS
  • We will go through installing the tools you need

This course is a very quick workshop to take you through the basic actions that will be required for you to create an awesome CRUD web application in just a few hours (you could do it over a weekend very easily) using ASP.Net MVC, the Entity Framework (code-first development approach), and the built-in scaffolding capabilities of ASP.Net MVC.

MVC = Model, View, Controller, and is a well-known and established design pattern. Microsoft has made it extremely easy and convenient to create your web solutions using this pattern. In Microsoft's MVC framework, we find that convention is favored over configuration, so as long as we follow a few simple guidelines, the system will do a lot of the work for us.

We'll also be taking a quick look at how we can use the Entity Framework to easily model and create a database for us. By using the code-first approach, we'll simply create our models and then look at writing a DBContext to store the models. We'll also create an initializer class which will see our database for us, so that we can quickly and easily test our system.

After we've learned about the different aspects of our application, we'll quickly create a controller and use ASP.Net MVC's built-in view and scaffolding generators to easily build our CRUD operations against our database.

Other things we will learn throughout the course involve the use of Git for source control, pushing our repository to BitBucket, and linking an AppHarbor project to BitBucket so that we can get continuous integration setup.  

To close out the course, we'll put DataTables.js on our Index view so that we can easily show the data, as well as provide built-in javascript tools that will filter and sort the data for us.

By the end of the course, you'll be familiar with the major working parts of creating an Asp.Net MVC CRUD application and publishing to a public-facing website with a fairly nice and responsive UI.  You'll have working knowledge of Models, Views, and Controllers, as well as how they interact to create a functional web application.  You'll also be exposed to the Entity Framework and Code First Migrations with use of a SQL Server backend.  The best part is that although this sounds pretty daunting, it's actually quite easy with a majority of the work done for us.

Who is the target audience?
  • New ASP.Net MVC Developers
  • New Web Developers
  • Developers making the switch from .Net Web Forms to MVC
  • Web Developers switching from Java, Ruby, PHP, or another framework to .Net
Compare to Other ASP.NET MVC Courses
Curriculum For This Course
66 Lectures
Getting Started
5 Lectures 21:10

This is the introductory lecture for the course.  This lecture explains what this course covers, including creating a new ASP.Net MVC web application from the ground up and being able to deploy the application to AppHarbor using Git [BitBucket].  The application will use MSSQL as the database backend (one video covers setting up the free database at AppHarbor.  Additionally, we'll use Facebook to authenticate our users and allow them to each store their own contact information as they so desire.

Preview 03:56

The entire idea for this course came from a job posting that I saw a couple of years ago.  Essentially, the task was to create a public-facing website that allows the user to store "Person" objects with critical details like name and phone number.  In addition to the minimums they ask for the ability to be able to filter and sort, add, delete, and modify the items.  We'll learn how to do all of this very easily in this course, and by the end of the course would have a public-facing URL that could be sent with our application for this position.

Preview 04:31

For our course, we'll be developing our project in Visual Studio Community 2015.  This is a completely free editor that allows us to do all of the main things that are needed to be done to create our projects in the .Net framework.  This video will show how to get the editor and install it on our machine.

Preview 04:26

This video just allows us to make sure we have the version of MVC we are looking to use for our course ready to go.

Preview 03:23

This video takes us through the creation of the project that we'll be building for the remainder of the course.  When we create a default MVC project, we're set up with the tools and frameworks we need in order to create a fully-functional web application in ASP.Net MVC with C#.  We'll modify some of this and we'll still need to add in our database information in future lectures, but we'll see that things are wired up pretty well right out of the box.

Preview 04:54
Setup and Configuration
9 Lectures 39:27

In this video we are going to blow away some of the default folders so we can set up our project with a more-common web layout.  We'll also get a chance to work through the restructuring to see how the different components work together.  For our web app to be complete, we'll need to recreate a folder for our javascript and css and also will have to add in a folder for images.  We'll be taking care of most of that in the next few lectures.

Preview 03:53

JQuery is one of the most powerful and widely-used javascript libraries available.  JQuery allows us to quickly work with javascript to build robust UI experiences on the client side of our application.  While we won't be using a lot of it in our course, we'll need it in order to work with Bootstrap, as well as having this is a common staple in .Net development.

Preview 03:47

One of the most widely-used and powerful responsive frameworks for web development is Bootstrap.  Bootstrap is a wrapper on CSS that allows us to quickly and easily skin sites and have them respond directly to the sizing of our device, from a small phone to a midsized tablet to a fullscreen monitor.  By custom tailoring our site, we'll be able to have the pages work differently in order to render correctly on each device.  We won't be learning a lot of Bootstrap in this course, but our site will rely on it for the overall layout.

Preview 04:31

Bootswatch is a cool site that allows us to grab a free skin for our Bootstrap layout.  We don't absolutely need to use this, but this is the quickest way to go from a vanilla look to something that looks a lot more professional, just with simple color schemes and default settings.  We'll pick our favorite free template and use that in our site.

Preview 03:22

One of the requirements for the original job-posting is to be able to easily filter and sort on the different contacts that we'll be working with.  DataTables is a powerful javascript library that allows us to easily do the filtering, searching, and sorting that was requested in the original post.  This is a great tool to have in your toolbox for professional development as it will be useful in many different situations in the professional world.

Preview 10:01

Every website should have it's own unique CSS file to keep track of certain aspects of the site that are unique to it.  In this video, we create the site.css file that will store our unique css styles for our website.

Preview 02:23

The bundle config is a file that lets the system easily put groups of css and javascript files into a "bundle" and then perform a simple reference to use them on our web pages.  Since we wiped out a lot of the core folders and have changed some of the files we're using and their locations, we need to reset the bundle config to work with our layout.  This video will take us through getting the bundle-config back to where it needs to be.

Preview 08:19

The layout.cshtml file is the file that all of our views will inherit from.  As such, common structures like the NavBar and footer are located here.  Also, we'll note that the section has a "RenderBody" call that will feed in the specific code for the view being rendered.  There is also a place to render scripts, which allows individual views to be able to render their own javascript scripts and have them run at the appropriate time.

Preview 03:00

The files attached at the end of each section will be my files as they were at the end of the section with some of the private information (passwords) and any Git references removed.  Please note that these files are really for reference only.  You should be building your own version of the site as you go to maximize your learning.

Source Control
7 Lectures 33:51

In our course we'll be relying on Git via BitBucket to set up and maintain our coding repository.  In order to easily work with Git, we'll walk through the installation of a Git Client for Windows.  

Preview 03:54

Every project needs to have a repository that stores the information about the files and folders involved in the project.  In this video, we'll create a Git repository on the folder with our project.  This will allow us to commit our code to the repository.  The advantages of the repository are that the repo will allow us to easily see and track our changes, rollback to a previous version of our code if something goes horribly wrong, and ultimately can share our code with other team members who can then do modifications.  By having the repository, team members could easily collaborate and make changes, check them in (commit), and everyone can pull the latest version to get the most up-to-date code at anytime.

Create the Repository

BitBucket is my favorite place to store code, simply because they allow you to make private repositories.  If you are already using GitHub and/or want to use GitHub for this project, you should feel free to do so.  While I'll be doing the videos in BitBucket and wiring up AppHarbor to link to my BitBucket account, there is no reason you cannot do that with GitHub (or other tools).  AppHarbor will for sure link to either BitBucket or GitHub, so either is perfectly acceptable.  Just remember if your repo is public, you will probably want to encrypt your AppSecret, AppId, and connection Strings so that others would not have access to them.

Once we have our source 'committed' then it is time to push it out.  To "push" out the code means to upload it to the common repository.  Since we are working by ourselves at this point, we don't need to worry about anyone else and should have admin rights so we won't have to ask to have our code merged into the default branch (in fact, we'll only be working on the default branch).

In this video I'll create the repo on my BitBucket Account.  You'll need to set up your BitBucket account if you don't have one and then you can create your repo in the same manner.  

Get an account and push our source to BitBucket

While we could use Microsoft's Cloud hosting - Azure - to do our applications. I have found that it is incredibly easy and FREE to work with AppHarbor for basic applications.  AppHarbor also works like Azure in that you can spin up more worker processors or a larger database as needed (for a fee, of course).

You'll need to create an account at AppHarbor, and then follow along with the video to create the project at app harbor.  

Get an Account at AppHarbor

Linking our Repo to AppHarbor is a quick and easy way to ensure that our code is automatically deployed when we create a new commit on the main branch of our repository.  Using GitHub should have similar results as AppHarbor will allow you to wire up to GitHub as well.  For our videos, we're using AppHarbor with BitBucket, and this video will show how to create the link.  A really nice feature is that every time the code is committed, AppHarbor will build and deploy the new version without us having to do any extra work.  After the code is built and deployed, AppHarbor will also place a comment on our repository at BitBucket to let us know that it is complete.

Link our Bitbucket account to AppHarbor

This video exists because I ran into an unexpected problem with AppHarbor and the Roslyn files from ASP.Net.  The good news is that you get to see me sweat through a couple of changes and attempts to fix the application deployment.  In the end, we figure out the correct fix and get the application to deploy and work on the AppHarbor site.  I could have gone back and fixed this so that you would not know I had these errors, but I wanted to leave them.  This is the kind of thing that you will encounter all the time as a developer, so it's good to see that everything is not always just bells and whistles.  In the end, we get it working and we get to see how that happens.  That's pretty cool.

Supplemental Instruction

The files attached at the end of each section will be my files as they were at the end of the section with some of the private information (passwords) and any Git references removed.  Please note that these files are really for reference only.  You should be building your own version of the site as you go to maximize your learning.

12 Lectures 51:31

Taking a step away from our application for a moment, we'll go out to Facebook for developers and create an application.   To make this work, you'll of course need a facebook account and register to work as a developer for facebook applications [this is all explained on the facebook site if you have questions].  

I should have just setup a test project right away (I have to do that in a later video).  That being said, if you follow along with the videos you'll be just fine.  Here we set up our facebook application that we'll use to allow users to authenticate on our site via their facebook login.  

I really love the idea of third-party authentication.  This means that I don't have to store a password locally and also means that it reduces the risk to me as the creator of this application.  If users login via a third-party, then the security is mostly on them for authenticating the actual person, and I just have to wire-up my app to correctly integrate the interaction with that third-party provider. 

Create Your App on Facebook

Please review this article before moving to Lecture 23 about Facebook Authentication.

Preview 00:52

********* PLEASE NOTICE: Please make sure you have completed Lecture 23 before doing this lecture.  If you do not upgrade your Facebook OWIN package, you will most likely get stuck at login when trying to use Facebook. *****************************

Once we have our application setup at Facebook, we need to set the web project to use Facebook authentication.  This video walks through how to make that happen in our web application.

Add Facebook Authentication to the project

This video is a live demonstration of registration with the newly wired-up Facebook authentication.

Register with our Facebook ID

Of course not all of our users will have a third-party option.  Luckily, ASP.Net authentication comes with powerful registration and account management tools out of the box for our application.  

This video just walks through registering via the local application, in the absence of any third-party provider.

Register using native built-in authentication

Now that we have authentication, we see that it's stored in a database locally.  When we move the application to the web, we need a database that is accessible to the web application.  In this video, we'll go out to our AppHarbor account and go to the project we are working on and create a new free database instance to use in project.

Create the database on AppHarbor

By default, ASP.Net Web applications use the web.config file to find things like connection strings and other variables that are needed to make our web systems work.  The nice thing is that we can use the web.config.release version to create settings that are specific for our web deployment in production. 

In this video, we'll modify the web.release.config to contain our settings for the AppHarbor database.  When we deploy, then we'll be connected to the web-accessible database, and not the database on our local machine.

Add Release configuration for database settings to point to AppHarbor

Since we have a local test application and a production release application, it only makes sense that we would have both a test and a release version of the application on Facebook.  In this video, I go back and make the test application on Facebook that we'll be using locally.

Setup Test Application on Facebook

Now that we have both the test and production versions of the application for Facebook, we also need to make sure that we can pull the correct settings from our appropriate web.config file.

In this video, we'll set up the appid and appsecret keys in the web.config and wire our application to pull from them.

Make our AppId and AppSecret pull from web.config

To deploy our application when things are correctly wired up, all we need to do is check our changes into our repository.  This will then use the continuous integration that we've wired up to build and auto-deploy at App Harbor.  When this is complete, we can go out and view our changes on the recently deployed version.

This video shows me checking in my changes and then running into a couple of small surprises after deploying.  Again, I could have edited all this out, but I really feel that you seeing me struggle through this and troubleshooting will give you more of a real-world feel, as this is yet another example of the types of things we run into as developers.

Deploy by checking changes into source control

In this video, I walk through the problems I was having with the release configuration.  This is a good chance to see how important it is to review what is actually going to deploy in your config files.  Once I saw what it was doing, I was able to figure out a way to create the config so that the correct keys would work as expected, and we were actually hitting the correct Facebook AppId and AppSecret.

Fixing Web.Config transforms to point to correct AppId and AppSecret

The files attached at the end of each section will be my files as they were at the end of the section with some of the private information (passwords) and any Git references removed.  Please note that these files are really for reference only.  You should be building your own version of the site as you go to maximize your learning.

Creating Models
4 Lectures 20:27

It's incredibly important to be able to restore our project from the repository when things go wrong.  In this video, I restore my project from the repo.  Here I note that I never saved the local database files to the repository, so that means they need to be recreated. In a normal situation, there would not already be the database registered on the machine (and even if there is you could remove it with Sql Server Management Studio Express).  

Had I shut everything down, I could have saved my local database files to the repo, but I didn't do that. So now the dilemma is how to proceed.  The easiest way is just change the filename so that it creates a new database and does not run into a conflict.  Again, ordinarily you would not need to do this step and would be able to easily restore to a new machine or clean machine.

Restore from source control

The "M" in MVC is Model.  Models are the code classes that allow us to describe our objects in detail.  In this video, we'll create the contact model with all the properties we'll need to store the data for each of our contacts in our systems.

The Contact Model

Make sure that as you progress and hit a level where you would want to restore to that you check your changes into source control.  There is no penalty for the number of times you check in.  In fact, some workplaces mandate checkins by day or even by a shorter interval.  Ultimately, you need to find your own groove!

Reminder: Check your changes into source control

The files attached at the end of each section will be my files as they were at the end of the section with some of the private information (passwords) and any Git references removed.  Please note that these files are really for reference only.  You should be building your own version of the site as you go to maximize your learning.

Views and Controllers
5 Lectures 26:36

The "C" in MVC is Controller.  In our application, the Contacts Controller is where the logic will happen and the routing will happen.  The requests come into the controller with the correct HTTP verb (GET/PUT/POST/etc).  Once the request comes in, the controller runs the correct code to accomplish the task and passes information to the View (the "V" in MVC).  The good news is that ASP.Net MVC will set up a lot of this for us when we create the objects.

In this video, we'll create the controller and have it scaffold our views so that we'll have CRUD operations wired up without having to write any code.  Of course we will modify this a bit as we go.

Create The Contacts Controller

In this video we will take a look at the controller methods that will respond to the appropriate HTTP Verbs as requests are routed to the controller.

Looking at the Contacts Controller

Now that our Controller scaffolded our Views for us, we should take a look at the resulting views.  We'll note that each Controller will get it's own folder to hold views and that the folder will be named exactly the same as the controller without the word "Controller."  This will allow us to easily see which views go with which controller for our projects.

In this video, we'll look at the views that were created for Details, Index, Create, Edit, and Delete.

Review the Views

In this video we'll do just a bit more with source control to make sure we are checking in and committing our changes and to make sure we are comfortable with the process.  

More Source Control Info

The files attached at the end of each section will be my files as they were at the end of the section with some of the private information (passwords) and any Git references removed.  Please note that these files are really for reference only.  You should be building your own version of the site as you go to maximize your learning.

The Database [Entity Framework]
8 Lectures 41:54

We'll set up two different database connections (even though we're connecting to the same database).  This allows us to keep our authentication separated from our application logic.  In this video, we need to create the db migrations to set up the Migrations for our ContactWebContext.

Create the Contact Web Migrations

Now that we've created the ContactWebContext, we need to add the settings to the web config.  This will allow us to make sure to connect to the correct database when we release.  We'll see later that the way this works is a bit tricky so it won't work as we set it up here, even though it looks like it should.

Add the ContactWebContext db connection to the web.config.release

In order to set up some data, we need to find out what our UserId is.  In this video we take a look at a couple of different ways to get that information.

Find our UserId

Seeding data allows us to put data in code that will actually be inserted or updated in the database at the start of the program after it is deployed.  This is a quick and easy way to set up some data that we can see on the website and start to interact with.  In this video, we'll set up some seed data.

Seed Some Data

In this video we'll set up authorization so that the user has to be signed in to be able to work with the specific views that list, create, edit, or delete contacts.  Furthermore, not only does the user have to be signed in to work with the data, but with the correct setup we now can ensure that the correct user only sees their own contacts.

Add Authorization and respond to the correct user

In this video we check in our changes and deploy so that authorization is in place.  This is part one of two as we'll have to do a quick correction on the web config in part two to get things working as expected.

Check in and make sure the changes propagate and work on AppHarbor

When we created the release config for the contact web database, we set up keys in the transform that made sense to replace.  However, what we find is that the transform didn't work as expected, so we have to do a remove and insert in order to get things working as expected.  In this video we get that taken care of so that the database will be correctly referenced.

Final Fixes for a successful deploy after adding in Database changes

The files attached at the end of each section will be my files as they were at the end of the section with some of the private information (passwords) and any Git references removed.  Please note that these files are really for reference only.  You should be building your own version of the site as you go to maximize your learning.

Make our application worthy of going public
11 Lectures 01:07:24

Using Bootstrap, we can set the class on our main container to "container-fluid" which will expand the content so that it takes up the entire page width.  In this video, we will set up our containers to work as container-fluid.

Render Across the whole page

The top-level navigation bar is one of the most important aspects of our site.  Without it, the users won't know where to go to get to the correct information that we want them to be able to use.  We need to setup the Navigation so that we have a direct link to our Contact Management pages.  We can easily do this by pointing to the correct controller and view/controller method for responding to the "GET" request when clicking on the link in the navigation bar.  This video will show us getting our navigation bar cleaned up and ready for deployment.

Cleaning up the NavBar

This video is going to clean up a few of our layout and rendering issues.  The first thing we will do is cleanup the footer and review what we can clean up in the _Layout.cshtml common layout page.  Then we move to the _LoginPartial.cshtml view, which allows us to change how the login controls render.  We add a new css class for padRight8px and then use that to render our page so that login controls don't render right up to the right side of the screen.

Cleaning up common layout and login partial layout

In this video, we review the Index view.  We note that the index has a default model of a list of contacts.  This allows us to easily have a list of the contacts in our system and put them into a table.  We review how the table lists out each of the model properties for each of the contacts in the system.  Use the file for contact index display table to get the code for the page without having to type it all out by name.  By the end of the video it will be clear how the data is displayed on the view.

At the end of the video, we set up our scripts area to prepare us for the datatables script that we'll be using for filtering and sorting.  We set the script up wrong on purpose so that we can show how the rendering works.  In order to complete this correctly, we need to make sure to put all of our scripts into the render scripts section.  Now that we know about that and have our page wired up for scripting, we are ready for putting in the datatables script to make our data render nicely in datatables.

Index Table Layout and Adding Scripts to our Views

In this video, we go over adding the script in place to render our data using DataTables.   We talk a bit about the id selector and how to reference that in JQuery with the "#" [hastag] identifier.  This allows our DataTables to target the correct table.  Then we talk about how to line up our DataTables script with columns on the table, and how to make the columns have default or adjusted widths. We look briefly at the rest of the settings for datatables and know that we can refer to the site documentation in the future to find out more information as needed.

Adding DataTables to our Index View

In this video, we fix up the Create View so that have the ability to create without showing the UserId to the users.  This is important to keep that information secret and also keep it available for the ability to store a contact in the database under their profile.  

As we go through the Create.cshtml, we talk a bit about razor syntax and the JQuery validation option that we had removed at the start of our course.

We then run the page and create a contact, verifying that the UserId is not shown and that we can create a contact and save it into the database.

We finish up by showing that we need to store the userid in a way that persists across some posts, in case of error or in the case when the view is re-rendered and we didn't put the userid into the ViewBag.  Once we do that, we get the page saved as expected.

The Create View

Now that we have our page looking a lot nicer and ready to go, it's time to talk about making a better UI experience for the users.  JQuery UI is a powerful tool that allows us to quickly add some pre-formatted controls to the page and use them to give our users a better experience.  In this video, we'll take the time to add in a simple date-picker control.  By doing this, the user will be able to easily select a date and have it render into the control for saving.  By doing this, the user won't have to type dates in any specific format on their own, and we'll also ensure that data coming in on the Post is formatted correctly as a date, so this is definitely a win-win for everyone.

JQueryUI for DatePicker

So far we've fixed up the Create and Index.  It's time now to fix up the Edit page.  Here we need to remove the user id from display, and add the datepicker for the birthdate.  As mentioned in the video, a lot of this will be extremely similar to the create page, so we'll be practicing the same things one more time.

A more advanced user might want to take the time to look into a partial view.  There are a lot of similar elements here that exist in both Create and Edit, and it might be possible to put all the common stuff into a partial view and then use that partial view for the create and edit views to eliminate some duplicate html/razor code.  We won't be going to this level in our course, but it is something you might want to look into for the future.  Just remember - ANYtime you find your pages having a lot of repeated/similar layout, think about using a partial view.

The next part of this video shows how a URL hijacker might be able to get to data that we don't want them to see.  With that in mind, we add another code check in place to make sure that the user can only see valid contacts that exist for their own user id.  This is another critical piece that you should consider as a web developer, and you want to make sure to prevent users from hitting your pages in a way that might bring harm to your system or your other users.

In the final part of the video, I had made a mistake on the wiring up of the datepicker.  This is awesome because it allows you to see how I can quickly use the tools available to check if the code is working as expected, and when I eliminate all of that, I can then check my own code to see where I went wrong.  In this case, I put the needsDatePicker class in the wrong place, and once I move that to the correct place, our code works as expected.

The Edit View

In this video we will quickly fix up the Delete and Details page to handle the final security on the Delete operations and also making sure that the users can only see the details on a contact that is under their own user profile.

We talk a bit about how you could dress up the UI for these pages, but we won't be doing much of that in our course, and we'll leave that up to you to take it from here.  Of course we do want to make sure not to show the User Id on any of the views as we really don't want users to see that information.

The Delete and Details Views

I had fixed up the website and was all excited about the final deploy to AppHarbor, and when I got there, I found out that the UI was not rendering the JQueryUI images as expected.  For some reason (I'm not really sure why), the image paths were expecting to be under a path called Content/images on AppHarbor.  A quick and dirty fix for this was to just create the path as expected and put the images in that folder, and then we can see they rendered correctly in the release on AppHarbor.

One other thing to consider is to make sure that when you put content in your project that needs to be deployed on the webserver, you should right-click on the files and select "Copy if Newer" or "Copy Always" to make sure the content will be available on the webserver to be rendered.  This is especially important for things like PDF documents or other content files that you want the user to be able to reference or download.

Fixing Images for JQuery UI on AppHarbor Deploy

The files attached at the end of each section will be my files as they were at the end of the section with some of the private information (passwords) and any Git references removed.  Please note that these files are really for reference only.  You should be building your own version of the site as you go to maximize your learning.

Completing Our Study
5 Lectures 20:21

This video talks briefly about a couple of things we can do to make the site better and touches on some web debugging tools.

As you create your own sites, you want to be able to dress-up or fix rendering on your pages.  We talk briefly as a review that the layout should be handled on the views, and the interaction between the views and the database should be handled using models and controller actions.

We then move into a little bit of web debugging using the built-in dev tools in Chrome.  We show how to override/change styles so that we can see where we would need to modify the css files to reset colors, fonts, and other layouts.  We also take a look at using the "toggle devices" so we can view what our site would look like as it is rendered on various devices with various orientations.

How can we make the site better?

This video is a simple presentation on what we've covered throughout the course.   The presentation then goes on to talk about your next step for where you would like to go to learn concepts that are important.  Next steps will really depend on you and where you want to go.  Do you want to concentrate on the front-end?  Then perhaps just look into javascript, css, and js frameworks like Angular, and maybe a little WebAPI.  Do you want to do just backend development?  Then learn about database theory, how to set up and work with databases, and how to access them.  You can then think about things like WebAPI, EntityFramework, and WCF Services to get directly to your data.  If you want to be full stack, then for sure you'll want to start learning all of these things, and you can choose which way to lean first (web ui or database/server backend).

Finally, the lecture ends with a bit of discussion about how to actually learn technical topics and gives some solid strategies to go about learning anything in the technical field.

Next Steps

This video is just a brief wrap-up for our course.  I am grateful you chose to work through the material to this point and hope that you have found it useful and fun, and that taking this course has piqued your interest in becoming a more-advanced web-developer and/or has further enhanced your skills.  Hopefully, now that you've seen the MVC framework in action, you can see the power and benefit of using this framework for creating your next web application.  All the best to you!

Course Wrap-Up

The files attached at the end of each section will be my files as they were at the end of the section with some of the private information (passwords) and any Git references removed.  Please note that these files are really for reference only.  You should be building your own version of the site as you go to maximize your learning.


Please find links to my other courses attached.  I have created some solid courses and this gives you the ability to get into them for lower rates and be able to continue to learn with me.  I hope you loved this course and will consider taking other courses I offer to continue to expand your skills.  Please feel free to reach out to me and let me know if there is a topic you think I should cover in my next course!

Bonus Lecture - Links and Coupons for Other Courses
About the Instructor
Brian Gorman
4.3 Average rating
2,021 Reviews
48,455 Students
6 Courses
Software Engineer and Computer Science Instructor

I am an experienced .Net developer, previously certified as an MCSD .Net in [expired]. I have a masters of science degree in computer information systems, and a bachelor of science degree in computer science. I also have many years of experience instructing college courses online in SQL databases, C#/VB .Net programming, Java programming, and Microsoft Office. I have created many online technical training courses that can be found on various platforms like O'Reilly/InfiniteSkills, Udemy, and others. I also run MajorGuidanceSolutions, a training and consulting company ,while working fulltime as a .Net developer.