Developing ASP.Net MVC Web Applications

Course Code: 5032

Overview
Schedule classes
What you'll learn
Outline
Prerequisites
Who should attend

Overview

ASP.NET is an open-source server-side web application framework developed by Microsoft to enable programmers to create dynamic websites, web applications and web services. The MVC model uses three different logic layers to define web applications – the Business layer or the model layer, the Display layer or the View layer and the Input control layer or the Controller layer.

During the course, participants will learn to build advanced ASP.NET MVC applications using .NET Framework 4.5 tools and technologies. The course focuses on engaging participants in coding activities that would help them master development of ASP.Net MVC web applications. Participants will also be taught about the differences between ASP.NET MVC and Web Forms in order to gain a better understanding of both and know the best times to use each.

Schedule Classes

Looking for more sessions of this class?

Course Delivery

This course is available in the following formats:

Live Classroom
Duration: 5 days

Live Virtual Classroom
Duration: 5 days

What You'll learn

Microsoft Web Technologies stack
Choosing the right technology for application development
Using the ASP.NET routing engine to create logical navigation hierarchies and simple URLs
Designing and implementing the architecture of web applications
Creating views in MVC applications
Ensuring consistency in the overall MVC web
Designing MVC models
Writing code for efficient implementation of business logic
Assigning controllers to MVC Applications
Writing JavaScript code
Using jQuery script library
Optimizing the responsiveness of MVC web applications

Outline

Module 1: Plan the application layers

Plan data access
Plan for separation of concerns
Appropriate use of models views, controllers, components and service dependency injection
Choosing between client-side and server-side processing
Design for scalability
Choosing between ASP .NET Core and ASP .NET
Choosing when to use .NET standard libraries

Module 2: Designing a distributed application

Design a hybrid application
Plan for session management in a distributed environment
Plan web farms
Run Microsoft Azure services on-premise with Azure Pack
Enable deferred processing through Azure features

Module 3: Design and Implement the Azure Web Apps lifecycle

Identify and implement Start, Run and Stop events
Code against application events in applications
Configure startup tasks including IIS, app pool configuration and third party tools

Module 4: Configure State Management

Choose a state management mechanism
Plan for scalability
Use cookies or local storage to maintain state
Apply configuration settings in web.config files
Implement session-less state including query strings
Configure middleware to enable session and application state in ASP.NET Core

Module 5: Designing a Cache strategy

Implement page output caching and data caching
Create cache profiles
Implement HTTP caching
Implement Azure Redis caching
Plan a content delivery network (CDN) strategy

Module 6: Design and implement a Web Socket strategy

Read and write string and binary data asynchronously
Choose a connection loss strategy
Decide when to use Web Sockets
Implement SignalR
Enable Web Socket features in Azure Web App instance

Module 7: Design a Configuration Management Solution

Manage configuration sources including XML, JSON and INI files
Manage environment variables
Implement Option objects
Implement multiple environments using files and hierarchical structure
Manage sensitive configuration
React to runtime configuration changes
Implement a custom configuration source
Secure configuration by using Azure Key Vault
Use Secret Manager tool in development to keep secrets out of code for configuration values

Module 8: Interact with the Host Environment

Work with file systems using file providers
Work with environment variables
Determine hosting environment capabilities
Implement native components such as PInvoke
Implementing native dependencies for hosts including Linux and Windows
Using ASP.NET hosting on an Open Web Interface for .NET (OWIN)-based server

Module 9: Compose an application by using the framework pipeline

Add custom request processing modules to the pipeline
Add, remove and configure services used in the application
Design and implement middleware
Design for Kestrel, HTTP Sys Web Server and IIS
Design and implement startup filters

Module 10: Design a browser artefact build strategy

Design a JavaScript build pipeline using Gulp, Grunt, npm and Bower
Design an artefact build strategy using Less, Sass and Font awesome
Design and implement a bundling and minification strategy

Module 11: Design a Server Build Strategy

Manage NuGet dependencies
Target runtimes including full .NET framework
.NET core
.NET standard
Manage debug and release configurations
Include or exclude files from the Build
Manage Build resources
Implement metadata for projects – version, release notes, descriptions
Define other build options – xmlDoc, warningsAsErrors
Working with static files in ASP.NET core

Module 12: Design a publishing strategy

Implement application publishing using dotnet.exe
Managing publishing options in csproj
Implement additional tooling
Implement pre-publish and post-publish scripts
Implement native compilation
Publish to Docker container image

Module 13: Implement as Azure Deployment strategy

Deploy Azure Web App using supported deployment models – FTP, Kudu, Web Deploy, Visual Studio Publishing Wizard
Provisioning ARM-based resources while deploying applications
Implement deployment environments – dev, test and prod in Azure
Using deployment slots for staging sites
Deploy to Azure Stack

Module 14: Implement on-premises deployment strategy

Deploy application to IIS using Web Deploy, xcopy and Visual Studio Publishing Wizard
Deploy application to Windows Nano Server
Deploy application to IIS Hosted Web Core
Deploy application to HTTP.sys web server
Deploy application to Kestrel on Windows and Linux
Implement reverse proxying to Kestrel using IIS and Nginx

Module 15: Create elements of the user interface for a web application

Create and apply styles by using CSS
Structure and lay out the user interface by using HTML
Implement dynamic page content based on a design

Module 16: Design and implement UI behavior

Implement client-side validation
Use JavaScript to manipulate the DOM
Extend objects by using prototypal inheritance
Use AJAX to make partial page updates

Module 17: Design the UI layout of an application

Implement partial views and view components for reuse in different areas of the application
Design and implement pages by using Razor Pages
Design and implement layouts to provide visual structure
Define and render optional and required page sections
Create and use tag and HTML helpers to simplify markup

Module 18: Plan a responsive UI layout

Plan for applications that run on multiple devices and screen resolutions
Use media queries and Bootstrap’s responsive grid
Detect browser features and capabilities
Create a web application that runs across multiple browsers and mobile devices
Enable consistent cross-browser experiences with polyfills

Module 19: Plan mobile UI strategy

Implement mobile specific UI elements such as touch input
Low bandwidth situations
Device orientation changes
Define and implement a strategy for working with mobile browsers

Module 20: Plan for search engine optimization and accessibility

Use analytical tools to parse HTML
Provide an xml sitemap and robots.txt file to improve scraping
Write semantic markup for accessibility
Use rich snippets to increase content visibility

Module 21: Plan and implement globalization and localization

Plan a localization strategy
Create and apply resources to UI including JavaScript resources
Set cultures
Implement server side localization and globalization

Module 22: Design and implement MVC controllers and actions

Apply authorization attributes, filters including global, authentication, and over-ridable filters
Choose and implement custom HTTP status codes and responses
Implement action results
Implement MVC areas
Implement Dependency Injection for services in controllers

Module 23: Design and implement routes

Define a route to handle a URL pattern
Apply route constraints
Ignore URL patterns
Add custom route parameters
Define areas
Define routes that inter-operate with Single Page Application frameworks such as Angular

Module 24: Control application behavior by using MVC extensibility points

Create custom middleware and inject it into the pipeline
Implement MVC filters and controller factories
Control application behavior using action results, model binders, and route handlers
Inject services into a view

Module 25: Design and implement serialization and model binding

Serialize models and data using supported serialization formats – JSON, XML, protobuf, WCF/SOAP
Implement model and property binding, including custom binding and model validation
Implement web socket communication in MVC
Implement file uploading and multipart data; use AutoRest to build clients

Module 26: Prevent and troubleshoot runtime issues

Troubleshoot performance, security, and errors;
Implement tracing, logging, and debugging including IntelliTrace
Enable and configure health monitoring including Performance Monitor;
Configure and use App Insights runtime telemetry

Module 27: Design an exception handling strategy

Handle exceptions across multiple layers
Use MVC middleware to configure error handling
Use different exception handling strategies for different environments
Create and display custom error pages
Configure a custom pipeline for error handling
Handle first chance exceptions
Configure and use App Insights
Log application exceptions

Module 28: Test a web application

Create and run unit tests, for example, use the Assert class, create mocks and stubs
Create and run web tests including using Browser Link
Debug a web application in multiple browsers and mobile emulators
Use Azure DevTest Labs
Use Visual Studio Team Services

Module 29: Debug an Azure application

Collect diagnostic information by using Azure App Insights
Choose log types – event logs, performance counters, and crash dumps
Stream logs directly to Visual Studio from a deployed site
Debug an Azure application by using Visual Studio and remote debugging
Interact directly with remote Azure websites using Server Explorer

Module 30: Configure Authentication

Authenticate users
Enforce authentication settings
Implement ASP.NET Core Identity
Enable Facebook, Google and other external providers
Implement account confirmation, password recovery, and multi-factor authentication
Authenticate using Azure Active Directory, Azure Active Directory B2C, Azure Active Directory B2B and Microsoft Identity
Manage user session by using cookies
Acquire access tokens using the Microsoft Authentication Library (MSAL)

Module 31: Configure and apply authorization

Create roles; authorize roles programmatically
Configure and work with custom UserStores using middleware
Configure controllers and actions to participate in authorization

Module 32: Design and implement claims-based authentication

Perform authentication and authorization using tokens including OpenID, OAuth, JWT, SAML, bearer tokens, etc.

Module 33: Manage data integrity

Apply encryption to application data
Apply encryption to the configuration sections of an application; sign application data to prevent tampering
Secure data using Azure Key Vault
Implement encryption for data protection using the data protection APIs in transit and at rest

Module 34: Implement a security site

Secure communication by applying SSL certificates
Require SSL for all requests
Enable SSL hosting in the development environment
Implement SSL using Azure Load Balancers
Salt and hash passwords for storage
Use HTML encoding to prevent cross-site scripting attacks (ANTI-XSS Library)
Implement deferred validation and handle unvalidated requests, like form, querystring, and URL
Prevent SQL injection attacks by parameterizing queries
Prevent cross-site request forgeries (XSRF)
Use Azure Security centre to monitor Azure resources
Implement Cross Origin Resource Sharing (CORS)
Implement protection against open redirect attacks

Prerequisites

Participants attending this course must have at least two to three years of experience developing web-based applications using Microsoft Visual Studio and Microsoft ASP.NET. They need to have three to five years of experience developing Microsoft ASP.Net MVC-based solutions and have an understanding of Microsoft Azure web apps. They would also need to have experience in designing and developing web applications in an ASP.NET MVC model, planning and designing user interaction solutions based on business requirements, working with the full software development life cycle of web applications, developing and deploying to multi-tier environments, including Azure; and designing and developing asynchronous solutions