Building an Enterprise Application with ASP.NET Core MVC

In this practical course, you'll learn how to build a line-of-business, enterprise application with ASP.NET Core MVC, including topics such as security, logging, testing, validation, and much more.
Course info
Rating
(63)
Level
Intermediate
Updated
Sep 18, 2017
Duration
6h 38m
Table of contents
Course Overview
Introduction
Authenticating and Authorizing Users with ASP.NET Identity
Hardening Your Site Against Attacks
Leveraging and Validating Complex Enterprise Data Models
Creating Clean and Maintainable View Code
Optimizing the Discoverability of Pages Using the Routing Engine
Creating Unit Tests to Support Business Changes Without Fear
Diagnosing Runtime Application Issues
Improving the Application's Performance
Automating the Deployment of Your Application
Description
Course info
Rating
(63)
Level
Intermediate
Updated
Sep 18, 2017
Duration
6h 38m
Description

ASP.NET Core introduces numerous features that web developers can put to use to build enterprise-ready, secure web applications with the new version of the platform. In this course, Building an Enterprise Application with ASP.NET Core MVC, you'll explore a fully-working web application, and will learn how you can scale it up from its current, rather basic state, to a state-of-the-art enterprise application. First, you'll discover how you can add and manage users and roles, and improve on the site's security. Next, you'll delve into how the new additions to the ASP.NET Core MVC platform such as tag helpers and view components can be put to real use. Then, you'll cover how to write tests for the different layers within the application, as a robust enterprise application requires a decent amount of unit tests to be ready. Finally, you'll learn how you can improve the developer experience using diagnostics and automated deployments to Azure. By the end of this course, you'll be ready to create real-world enterprise applications with ASP.NET Core MVC.

About the author
About the author

Gill Cleeren is a solution architect, author, and trainer in mobile and web technologies. He's also a Microsoft Regional Director and MVP. He lives in Tienen, Belgium.

More from the author
GitHub Fundamentals
Beginner
4h 16m
24 Sep 2018
Xamarin: The Big Picture
Beginner
2h 15m
28 Mar 2018
More courses by Gill Cleeren
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
Hi everyone, my name is Gill Cleeren, and welcome to my course Building an Enterprise Application with ASP. NET Core MVC. I'm a solution architect for web and mobile projects. . NET Core is the future of the. NET framework. It's where all investment from Microsoft will go to from now on. Since its inception about 15 years ago, this is the biggest change ever made to. NET and ASP. NET. If you're interested in learning how a real life line of business enterprise application can be created with this new version of ASP. NET Core MVC, this course will be your best friend. You'll get to see from a practical perspective how the common concepts, such as security, logging, caching, testing, and much more are implemented in a real life and fully working application. Some of the major topics that we'll cover include security and identity in ASP. NET Core MVC, testing your code with unit tests, adding logging to your ASP. NET Core MVC pages, improving the site's performance using caching, and continuous delivery and integration with VSTS. By the end of this course, you'll know how a real life enterprise application can be built with ASP. NET Core MVC. Before beginning this course, you should be familiar, however, with the basics of ASP. NET Core MVC. I hope you will join me on this journey to master ASP. NET Core MVC with the Building and Enterprise Application with ASP. NET Core MVC course here at Pluralsight.

Introduction
Hi there, and welcome to this course named Building an Enterprise Application with ASP. NET Core MVC. My name is Gill Cleeren, and it's great to see that you want to learn some interesting stuff about ASP. NET Core MVC together with me. You can always contact me with any questions you may have about this course or ASP. NET Core via Twitter or via a discussion board for this course here on the Pluralsight website. In the next couple of hours that we'll spend together, I'm going to try to teach you some of the more advanced things about the shiny new release of Microsoft's web development platform that is ASP. NET Core MVC. We're going to do this by starting from an existing web application and we're going to extend it with features that are typically used in a development of enterprise applications. So by the end of this course, you will have gathered a lot more knowledge that is indispensible when building real life enterprise applications with ASP. NET Core MVC. Every module in this course will start with a small overview of what we are going to do in that very module. So let's start with this tradition right here in the first module of this course. This module is an introductory module to the course, so we'll start with a short overview of the course and what you'll learn in the next couple of hours. Next, we'll take a look at the finished application that we'll be using and working with throughout this course. Finally, to finish this module, we'll spend a few minutes making sure that you have everything ready to follow along with me in this course in the topic getting your machine ready.

Hardening Your Site Against Attacks
Hello there, and welcome to this module on Hardening Our Site Against Attacks, part of this course on Building an ASP. NET Core Enterprise Application. I'm Gill Cleeren, and I'm excited to see that you're joining me for yet another module. Now in the previous module, we have covered a lot in regards to allowing the user to authenticate and to authorize in our application. Those features are, of course, related to security. However, there's much more to securing our application than just requesting that the user will be using a strong password, although that is definitely important. Now in this module, I'm going to discuss which measures we as developers can take to make sure that we don't open the application for some of the most commonly used types of attacks. So by the end of the module, you'll know how to secure your ASP. NET Core MVC application. As said, it's all about securing our site in this module. By no means will this module, or an extent, this course, try to give you all the measures that you should take against all kinds of attacks that might happen once your site is live. Instead, what I'm focusing on are two very common types of attacks that we often become a victim of, and for which the solution has changed quite a lot with the introduction of ASP. NET Core. So first, I'm going to explain about sanitizing input in order not to get caught by the XSS attack, or cross-site scripting attack. Well, as we have seen how we can do that, we're going to learn how we can also counter CSRF attack, so a cross-site request forgery attack.

Leveraging and Validating Complex Enterprise Data Models
Hi there, and welcome to this Pluralsight course on Building an Enterprise Application with ASP. NET Core MVC. My name is Gill Cleeren, and together we will be learning in this module about Leveraging and Validating Complex Enterprise Data Models. In many demos, most enterprise or line of business applications work with data. I think that is rather obvious. In many demos that you'll typically come across when you're learning about ASP. NET Core MVC, you will see a single string being entered in your view, and that string then arrives on the controller site. Now in real applications, things tend to get more complex typically. In this module, I'll be showing you the various ways you can get complex data models from the client to the controller, and also how to validate that the user has entered valid data. I will kick off the module with a short overview what you will be learning in this module. As mentioned, we'll learn about model binding. During this part of the module, you'll see the many types and many ways of model binding, which are supported by ASP. NET Core MVC. Secondly, we'll explore the options we can add on top of the binding engine to perform validation to ensure that only valid data will be entered in the persistence store.

Creating Clean and Maintainable View Code
Hi there, and welcome to another module of the Building an Enterprise Application with ASP. NET Core MVC course here on Pluralsight. My name was Gill Cleeren in the previous module, and I've decided to keep it that way for this module as well. And feel free to reach out to me with any questions you may have about this module via the discussion board here on the Pluralsight website. Now, the focus for this module is the view. We will be looking at quite some advanced topics that you'll come across when you build a real live enterprise application with ASP. NET Core MVC. Let's dive straight in. So as mentioned, we'll be spending time learning about several things that have to do with the view of the application. And probably one of the most interesting features that is new in terms of ASP. NET Core MVC is tag helpers. Now I won't be spending a lot of time teaching you about the basics of tag helpers; that was already covered in the introduction course. However, we will go a lot deeper in the options that we have with tag helpers. We will start the module by looking at some advanced built-in tag helpers. And after that, we'll go and create some more advanced tag helpers ourselves. And this we'll be doing mostly in demos. Next, we'll take a look at how we can create some asynchronous view components, and we will finish the module by exploring how it can translate our application into different languages, making it possible for the user of the application to switch between UI languages.

Optimizing the Discoverability of Pages Using the Routing Engine
Hi there, and welcome to this module titled Optimizing the Discoverability of Pages Using the Routing Engine. What a nice title I have come up with for this module, even if I say so myself. Just so you know, you're listening to Gill Cleeren here in this Pluralsight course named Building an Enterprise Application With ASP. NET Core MVC. As you may have understood from my wonderful title there, I'm really proud of it, this module is about more advanced routing topics. Using routing, we are able to make the pages within our site easy to reach and easy to discover using a search engine. This is, of course, for many companies the ultimate goal, since it will typically result in better sales when it's easier to find something on your site. Let's kick off the module by taking a look at the topics that we will explore in the module. As the very first item in this module, I will give you a brief overview of the routing engine and its options. If you are already familiar with the routing engine in ASP. NET Core MVC, feel free to skip this item. After we've seen how it works, we'll dive in the more advanced topics of this module. I'm going to start with attribute-based routing. We'll learn the different ways that we can use attributes in our controllers to control the routing of the application. Next, we'll discuss areas, which will also help in making the URLs for the application cleaner and more representative. Finally, we'll discuss how the routing engine can be used to create outgoing URLs. For example, to others places within the application. A lot of interesting stuff, if you ask me. Let's get started.

Creating Unit Tests to Support Business Changes Without Fear
Hello, and welcome to another module of the Build an Enterprise Application with ASP. NET Core MVC course here on Pluralsight. My name is Gill Cleeren, and you can contact me via Twitter via @gillcleeren. Now, this module should be a way to give ourselves some better sleep during the night. Now I won't be giving you any sleeping tips; I instead will be discussing how we can harness our ASP. NET Core MVC applications with some unit tests, so that we can make changes to our code without the constant fear of breaking things, and thus, a better night's sleep. Now let's see how we can do that in ASP. NET Core MVC. A good tradition is to start the module with a brief overview of what we will be doing in this course. And the list is actually rather concise for this one. I'll start with a brief overview of what unit tests are and why you need to add them to your code base in basically just any application, and that of course includes Bethany's Pie Shop. Now the meat of this module will actually come after that when we will be writing unit tests for the controllers of the application. Now in this context, we will also be using the mock framework to create mocks for our unit tests.

Improving the Application's Performance
Hi there, and welcome to this module of the Building an Enterprise Application with ASP. NET Core MVC course here on Pluralsight. My name is Gill Cleeren, and I'll be guiding you through this module. This module is titled Improving the Application's Performance. Ooh, performance. Getting more done with the same hardware, because we as developers have done a better job creating our code so that the application runs faster. That is what we will be discussing in this module. Let's for starters take a look at the topics we will be discussing in this module. First, we will take a look at the what and why of caching, and how it, from a bird's eye perspective, can help us with improving the performance of our site. Then for the rest of the module, we'll take a look at all the options that ASP. NET Core MVC offers us in this area. First, we'll take a look at the in-memory caching, a very simple, but in some cases, effective way to perform caching. ASP. NET Core MVC comes with a tag helper that is specific to caching, quite conveniently called the caching tag helper, and we'll explore that one, too. Next, we'll take a look at a more complex setup using distributed caching, and I'll be using Redis for this. Next, we'll take a look at response caching and the different options that ASP. NET Core is offering us here. Finally, we'll take a look at how compression can be done, basically to limit the amount of data going over the wire, and this way also improving the application's performance. A lot of things to cover. Let's get started.

Automating the Deployment of Your Application
Hello there, it's that time. You have reached the last module of this course. But no fear. In this last module of the Building an Enterprise Application with ASP. NET Core MVC course, we're going to have some more fun together. Also for this last module, my name hasn't changed, so that is still Gill Cleeren. Let me know if you have any questions about this course via the discussion board here on the Pluralsight website. Now in this last module of this course, we are going to focus on the automation of the deployment process of the application. After this module, you'll have an example of how to set up the automated build and deployment of Bethany's Pie Shop to Azure. For the last time, let's take a look at the outline of the module before we're getting started. Since we will be using VSTS, Visual Studio Team Services, for this course, we will start with a brief overview of the platform. Feel free to skip this part if you're already experienced with VSTS. Once we have finished the overview of VSTS, it's time to set up continuous integration with it, and as the last topic for this course, we are going to take things a little bit further, so that we also have an automated deployment of the site onto an Azure App Service. If you've watched the intro course before, you may have seen that we have already done a regular deployment to an Azure App Service. Now in this course, we'll take things a bit further. Let's get started.