Module 1: Client-Side Development
When creating an application, it is important to know how to develop both client-side and server-side code for the application. In this module, you are going to learn client-side tools that will allow you to create complex web applications on any scale, including using the Bootstrap CSS framework to style your web application. You will learn how to use Sass, a CSS pre-processor that adds code-like features such as variables, nested rules, and functions, that improve the maintainability of complex CSS stylesheets. You will learn responsive design principles that allow you to adapt your web application based on the capabilities of the web browser or device using CSS media queries, and how to use a responsive grid system. Next, you will learn how to set up the gulp task runner and use it to compile Sass files during the build and perform bundling and minification of CSS and JavaScript files, and how to set up a watcher task to automatically compile Sass files as you write your code. Finally, we’ll introduce the Blazor framework for building an interactive client-side web UI with .NET.
Lessons:
- Responsive Web Design.
- Using Front-end Development Tools.
- Looking at ASP.NET Core Blazor.
Lab 1: Client-Side Development
After completing this module, students will be able to:
- Use Bootstrap and SASS in a Microsoft ASP.NET Core application.
- Use front-end development tools.
- Ensure that a web application displays correctly on devices with different screen sizes.
- Understand ASP.NET Core Blazor applications.
Module 2: Testing and Troubleshooting
The process of software development inevitably results in coding errors or bugs that result in exceptions, unexpected behavior, or incorrect results. To improve the quality of your web application and provide a good user experience, you must identify bugs from any source and eliminate them. In traditional software development, testers perform most of the testing at the end of a development project. However, in recent years it has become widely accepted that testing throughout the project life cycle improves code quality and greatly reduces the quantity of bugs in production software. You need to understand how to run tests on individual components to ensure that they function as expected before you assemble them into a complete web application. It is also important that you know how to handle exceptions when they occur and handle them correctly to provide appropriate user feedback, without leaking information about the application structure. Finally, by using logging throughout the application, you can monitor user activities that might lead to unexpected issues and troubleshoot production problems by tracing flows through the application.
Lessons:
- Testing ASP.NET Core Applications.
- Implementing an Exception Handling Strategy.
- Logging ASP.NET Core Applications.
Lab 1: Testing and troubleshooting
- Testing and troubleshooting.
After completing this module, students will be able to:
- Run unit tests to verify code and locate potential bugs.
- Build a Microsoft ASP.NET Core application that provides robust exception handling.
- At application logging to your solutions.
Module 3: Managing Security
Applications are normally delivered through a web browser, by means of the public Internet, to large numbers of users. This means that security must always be at the forefront of your mind when building these applications, because as well as legitimate users, the application will be exposed to malicious third parties. Users may have anonymous access, or they may have a signed-in identity, and you must decide which users can perform what actions. Authentication is the act of establishing a user’s identity, while authorization is the process where an already authenticated user is granted access to specific actions or resources. By utilizing authorization, you can prevent users from accessing sensitive material or information and resources intended for another user or prevent them from performing certain actions. The costs of security breaches can be very high, resulting in loss of data, legal action, and reputational damage. So, in the final section we will look at some specific malicious attacks such as cross-site scripting and SQL injection, and how to defend against them.
Lessons:
- Authentication in ASP.NET Core.
- Authorization in ASP.NET Core.
- Defending from Common Attacks.
Lab 1: Managing Security
After completing this module, students will be able to:
- Basic authentication to your application.
- Configure Microsoft ASP.NET Core Identity.
- Add basic authorization to your application.
- Understand how security exploits work and how to better defend against them.
Module 4: Performance and Communication
Modern web applications need to be able to respond quickly to large numbers of user requests within a small timeframe. Caching allows you to store common requests, avoiding the need to perform the same logic repeatedly. This provides the user with a fast response time and reduces system resources used in conducting the logic for the action. By utilizing various forms of state management, you can build stateful applications on top of stateless web protocols, to give responses tailored to individual user contexts within the same application. Finally, SignalR is an easy-to-use bi-directional communications API that is an abstraction over several different web communications protocols. This allows you to build server-side logic to push content to browser-based web applications in real time.
Lessons:
- Implementing a Caching Strategy.
- Managing State.
- Supporting Two-way Communication.
Lab 1: Performance and Communication
- Performance and Communication.
After completing this module, students will be able to:
- Implement caching in a Microsoft ASP.NET Core application.
- Use state management technologies to improve the client experience, by providing a consistent experience for the user.
- Implement two-way communication by using SignalR, allowing the server to notify the client when important events occur.
Module 5: Implementing Web APIs
Most web applications require integration with external systems. Representational State Transfer (REST) services help reduce application overhead and limit the data that is transmitted between client and server systems using open standards. You need to know how to expose a Web API that implements REST services in your ASP.NET application. You also need to know how to call a Web API by using both server-side and client-side code to consume external REST-style Web APIs.
Lessons:
- Introducing Web APIs.
- Developing a Web API.
- Calling a Web API.
Lab 1: Implementing Web APIs
After completing this module, students will be able to:
- Create services by using ASP.NET Core Web API.
- Call a Web API from server-side code.
- Call a Web API from client-side code.
