Introduction to the Web
You can't start developing for the web without knowing the fundamentals of
the web. In this module, we explore the details and intricacies of the HTTP
protocol that makes client-server communication possible on the web. Furthermore,
we take a look at the REST architectural since it is a fundamental concept to be aware of
when transferring data over HTTP.
- Http Methods
- Status Codes
- RESTful Architecture
In this module you will learn about ASP.NET Core which is Microsoft's web development framework.
We will see how HTTP requests are processed within ASP.NET as well as a
high-level overview of the available technologies for developing web apps within
ASP.NET Core, such as MVC, Blazor, Razor Pages and Web API.
- ASP.NET Core Introduction
- Server- versus Client-Centric Applications
- ASP.NET Core Technology Overview
- ASP.NET Core Request Processing Pipeline
The 3 Main ASP.NET Core MVC Components
In this module you will learn about the MVC pattern and why this pattern
fits so well in the world of websites and web applicatons.
Once you understand MVC, you need to learn how it is implemented in
ASP.NET Core. This module explores the most important components of the
framework and how they work together.
- The MVC Pattern in ASP.NET Core
- Handling the user interaction with Controller
- Rendering the response with MVC Views
- Creating a MVC Model and ViewModel
- Understanding Routing
- LAB: The 3 main ASP.NET Core MVC Components
On the web the URL decides what the server will do. In ASP.NET Core, this
is configured in the End-point Routing Middleware. A solid understanding
of this middleware will allow you to build complex, feature-rich
applications with ASP.NET Core.
- Getting Started with Routing Concepts
- Defining Routing Templates
- Route Parameter Constraints
- Route Parameter Transformers
- Understanding Route Matching
- Using Conventional vs. Attribute Routing
- Routing Attributes
- Request Short Circuiting
- Handling Routing Errors
- LAB: Routing in ASP.NET Core MVC
ASP.NET Core MVC Controllers
In this module we'll take a closer look at the C in MVC. The Controller
has a very important role to fulfill: It's the component that ties models,
views and business logic together when handling a request.
- Different types of Action Results
- Working with GET and POST
- Model Binding
- Action Filters
- LAB: using MVC Controllers
ASP.NET Core MVC Services and Dependency Injection
Services are simple objects used for implementing and encapsulating your business rules and logic.
By using Dependency Injection we can decouple services from their
dependencies. On top of improving maintainability and separation of
concerns, it also makes testing our services a lot easier. In this module you will use
dependency injection to enable clean architecture.
- What is dependency injection
- Methods of Dependency Injection
Dependency Inversion, Explicit Dependencies, and Inversion of Control
- Clean Architecture
- Using Services and Repository
- LAB: Setting up your project using Clean Architecture
Designing your Web App's Model
Your website exposes your business data and functionalities to external clients.
In this module you will learn how to model the data you expose
correctly so that it becomes easy to maintain and easy to consume.
To accomplish this, you will learn about ViewModels, an abstraction created to
help maintain a clean separation between the Model and Views.
- Designing your model
- Passing Data to a View
- Mapping between Model and ViewModel
- LAB: Using ViewModels
Introduction to Entity Framework Core
When a database is designed, the idea is to normalize data, i.e. avoid
duplicate data. When designing the object model for an application you try
to come up with a design which is best suited for solving your business
problems. This means that mapping tables to classes one-on-one is often a
bad idea. Entity Framework Core allows us to map the relational world to
the world of objects, allowing more complex mapping.
- What is Entity Framework Core?
The need for Object Relational Mapping, especially with inheritance
- Decoupling conceptual data structure from logical data structure
- Querying data: APIs and LINQ
Modeling your database with EF Core
Mapping in EF Core uses conventions, attributes, or Fluent API. In this
module, you will learn how to use these to model your database in EF Core
and apply updates in your model to your database with Code-first
- Methods of configuration
- Creating and applying migrations
- Table and column mapping
- Modeling properties
- Mapping Value generated properties
- Handling Concurrent updates
- Modeling relationships
- Mapping inheritance
- LAB: Mapping your entities to the database with EF Core
In this module we will explore Razor and its syntax. we start with the
basics, and end with some more advanced scenarios.
- Building and Scaffolding Views
- Understanding Layouts and Sections
- Cleaner razor with Tag Helpers
- Re-using Razor with Partial Views
- Introducing Blazor Components
- Adding Interactivity with Blazor Components
- LAB: Sections and TagHelpers
In this module, we will learn how to add client-side interactivity to our
can manipulate it, as well as handling user events in the browser.
- Understanding the DOM
- DOM Selection and Manipulation
- Event Handling
Responsive Web Design with Bootstrap
Your web site needs to look stunning on any device; whether it's a laptop,
tablet or phone. Let bootstrap be your guide towards a consistent looking
application in the messy world of media queries and responsive design.
- Normalizing and Resetting
- The Grid System
- Utility classes
- Bootstrap Components
- Customizing Bootstrap
Validating user input is important for two reasons: firstly, you don't
want to allow invalid or even dangerous content to be persisted in your
database. Secondly, when your users make mistakes, you want to help them
correct those mistakes. In this module we look at best practices,
validation options, and how to send feedback in case of errors.
- Explicit versus Implicit Validation
- Validating data using Data Annotations
- Self-Validating Models
- Validating using the Model Binder
- LAB: Data Validation
Authentication is about identifying who the user of the system is. In this
chapter we look at the different authentication mechanisms, their
use-cases, and how to implement them.
- Knock Knock... Who's There?
- Windows Integrated Authentication
- Username and Password Authentication
- Extending Authentication with your own Data
- Using the Microsoft Identity Platform
- Authorization with Policies
Building RESTful Services with Web API
When building more client-centric applications, you will have to send a
bunch of data back and forth between your client and server. Web API uses
REST to allow the client to access resources on the server. It is based on
the same principles as MVC.
- What is REST?
- Building a REST service with ASP.NET Core Web API
- Supporting multiple representations: XML and JSON
- LAB: Building a REST API
Consuming Web APIs
After you've built your back-end with Web API, it's time to jump over the
fence and take a look at how client applications will consume it. In this
applications can easily consume your Web API.
- Consuming a Web API from .NET
- Best Practices for the .NET HttpClient using IHttpClientFactory
- Using the Swagger CodeGen Client
- LAB: Building a Client for your Web API