Gain insights into creating dynamic web apps with ASP.NET Core MVC. Explore Razor, localization, advanced features, and best practices for building public and business applications.

ASP.NET Core MVC (Intermediate)_468 x 60 copy.png

asp.tar.gz

ASP.NET

ASP.NET-multi

ASP.NET-Secure

ASP.NET-copy

In this course, you will learn how to create a modular, dynamic web application with ASP.NET Core MVC, Razor, and Razor tag-helpers. Furthermore, you will also learn how to localize that application in several languages, and finally how to publish it.

You will cover many different aspects of ASP.NET development including: how to optimize user interfaces, validate user input, how to write clean and maintainable code with dependency injection and configuration data, and a whole lot more.

By the end of this course, you will be able to build both a public website and a business application based on ASP.NET Core MVC, with advanced features such as caching, authentication, and authorizations, and while conforming to Microsoft best-practices.

ASP.NET Core MVC

# Separation of concerns with the MVC pattern ##

The MVC pattern was conceived to split also the **Presentation Layer** into two sub-layers. The MVC pattern is specific to web applications. The **Presentation Layer** of desktop and mobile applications can be split into sublayers using a pattern that is slightly different called **MVVM (Model-View-ViewModel)**.

The Presentation Layer performs the following two tasks:

1. Handling the interaction pattern between the software and the user. This includes encoding the pattern of communication (how requests and responses evolve), validating user inputs, understanding which **Business Layer** procedures to invoke, and organizing the response data for a suitable presentation to the user.

2. Building an adequate graphic for each screen, that is, building adequate HTML and using adequate CSS. 

The basic idea of the MVC pattern is to make the task at point 1 completely independent from the one at point 2. That is, to make the logical part of the user-machine interaction independent from the way the whole graphic is implemented. This way we can modify the graphics completely without affecting the way the software is run.

This is important for the following reasons:

1. Graphic changes are frequent, and the above separation enables us to change the graphics without challenging the stability of the code.

2. Graphic is better implemented by a different professional role, the web graphic designer, and the separation of concerns between graphics and logic allows an efficacious splitting of the job between developers and graphic designers.

3. Performing exhaustive testing of the whole web page is very expensive and often the lifetime of the HTML graphic part is too short to justify the cost of building exhaustive tests. Separation of concerns makes the so-called partial tests, which act just on the logical part without interacting with the page HTML, more effective. Such tests are cheaper than complete tests. Instead of using all complete tests, we can implement most of the tests as partial tests on the logical part, and leave just a few complete tests.

Separation of concerns is achieved by using classes called ViewModels as interfaces between all the logical tasks and the HTML building tasks.  

The logical part is executed by a processor called **Controller** while the HTML building is performed by another processor called **View**. The controller performs all logical tasks of the user-machine interaction and outputs an object called a ViewModel. The ViewModel contains all the data to show the user and the View uses this data to build adequate HTML: 

In this lesson, we will learn about the MVC pattern in detail and how to split the functionalities of our application among several controllers.

Razor Template Language

Razor Language Assessment

Tag Helpers

Tag Helpers Assessment

Controllers and ViewModels

Controllers Assessment

Validation and Metadata

Validation Assessment

Dependency Injection

Configuration and Options Framework

Localization and Globalization

Factoring out UI Logic

Authentication and Authorization

Advanced Topics Assessment

Publishing Your Web Application

Conclusion

Appendix

The MVC Pattern

Separation of concerns with the MVC pattern