.NET Core has revolutionized the way backend applications are developed: dependency injection, Kestrel web server, advanced configuration management, logging, security, etc. These technologies are at the heart of .NET applications. To use them effectively, you need a solid understanding of the design patterns that structure a backend application.
This training will equip you to design and implement scalable, high-performance architectures using .NET and C#.
You will explore best practices in software design while implementing the key components of a backend application, from data management to securing REST APIs to deployment on Kubernetes.
Each module is based on concrete practical applications, using a progressive and structured approach.
Duration
5 days
Schedule
See training dates for details
Regular fee
$2,395
Preferential fee
A preferential rate is offered to public institutions, to members of certain professional organizations as well as to companies that do a certain amount of business with Technologia. To know more, please read the "Registration and rates" section on our FAQ page. Please note that preferential rates are not available for online training courses. Discounts cannot be combined with other offers.
$2,155
Objectives of the training
Be able to design and develop a complete, modular, and secure backend application with .NET and C#, according to proven software architecture principles.Targeted audience
Backend developers and scalable application architects in a .NET environmentPrerequisite
This course requires a solid understanding of the fundamentals of C# programming (principles of object-oriented programming, generic types, custom attributes, lambda expressions). Experience with Visual Studio, VsCode, or Rider is also necessary.Trainers
Benefits for Participants
Implement loose coupling with dependency injection;
Designing scalable architecture with the command pattern;
Accessing data from a relational database with an ORM;
Ensuring system consistency through transaction management;
Create the endpoints of a REST API with ASP.NET MVC;
Implementing an MVC frontend with ASP.NET MVC;
Securing a REST API with ASP.NET MVC, and OpenID Connect and JWT;
Deploy an application as an OCI image and deploy it on Kubernetes.
Course architecture
This training course is structured in progressive modules, combining theoretical concepts and practical applications. Each block addresses a key aspect of backend application architecture with .NET, from the foundations to deployment.
Introduction
This first module lays the conceptual foundations of software architecture in .NET, exploring design principles and the framework ecosystem.
- The adoption of a common language (ubiquitous language) for better collaboration.
- Setting objectives.
- Review of S.O.L.I.D., KISS, DRY, and POCO principles for better maintainability.
- The division into software layers.
- The preference for stateless applications.
- Overview of the .NET ecosystem.
Weak coupling with Microsoft.Extensions.DependencyInjection
This module presents dependency injection mechanisms in .NET and the associated patterns for promoting modular, loosely coupled code.
- Presentation of the Strategy and Factory design patterns.
- The declaration of an IServiceCollection.
- Registering a service.
- Dependency injection.
- Access to properties derived from an IConfiguration.
- Coupling with Microsoft.Extensions.Logging.
- La configuration par custom attributes.
Practical application: implementing dependency injection with Microsoft.Extensions.DependencyInjection.
Exchanging messages with the Command pattern
Here you will learn how to structure application logic around the Command pattern to improve code clarity, maintainability, and scalability.
- The command as a representation of user inputs for a use case.
- Routing commands to business components.
- Validation.
- Exception handling.
- Transactional demarcation.
- Implementing a CQRS (command query responsibility segregation) architecture.
Practical application: applying the Command pattern to reduce coupling and increase maintainability.
Data Access and Transaction Management
This module explores the principles of data access, database types, transactions, and patterns such as Unit of Work and Repository.
- Different types of databases (SQL, NoSQL).
- The CAP theorem.
- Non-blocking execution of I/O operations to improve scalability.
- The role of a connection pool.
- Transactions and ACID principles.
- The Unit of Work pattern.
- Records and tuples for manipulating immutable data.
- The Repository pattern (and its limitations) and its implementation in .NET: EntityFrameworkCore.
- Mini-ORMs as a solution for developing data-driven applications, introduction to Dapper.
Practical application: implementation of the Unit of Work pattern for transactional data access, querying a database with Dapper.
Creating a REST API with ASP.NET Mvc
You will learn how to build a robust REST API in .NET while following best practices for design and testing.
- The Kestrel embedded web server and its event loop.
- Middleware.
- Best practices for designing a REST API.
- API Controllers and request processing.
- Validation.
- Exception handling.
- Testing a REST API.
Practical application: creating a REST API to expose the previously developed application.
Creating an MVC web application with ASP.NET MVC
This module guides you through the creation of a web user interface based on the MVC pattern, using Razor views and partial views.
- Introduction to the Model View Controller pattern.
- Defining the model and transmitting it to the views.
- Razor views.
- Ajax and partial views for smoother navigation.
- Validation.
Practical application: creating an MVC frontend.
Securing a web application
You will learn how to integrate authentication and authorization mechanisms into a secure web application with JWT, Identity, and OpenID Connect.
- Declaring a user repository with ASP.NET Identity.
- Choosing an authentication strategy: cookie or JWT token.
- Coupling with an OpenID Connect server.
- Defining access rules.
- Accessing user identity.
- Revocation strategies.
Practical application: securing the REST API with JWT.
Continuous integration and continuous delivery
You will cover the key steps in delivering a containerized application with .NET, from image generation to deployment on Kubernetes.
- Review of .NET commands for creating a deliverable.
- The 12 Factor App methodology.
- OCI image creation.
- Deploying an OCI image on a Kubernetes orchestrator.
Pratical application: creating an OCI image from the REST API and deploying it on Kubernetes (Minikube).
Pedagogical details
Training architecture
Explanation, for each concept, of the problem it aims to solve. Practical application of a concept immediately after it has been presented. Validation of each step by performing unit tests. "Common thread" exercise to obtain a complete application at the end of the course. Multiple-choice questions at the end of each chapter to ensure knowledge acquisition.
Type of training
Skill development
Skill development and knowledge integration
Decision support
Basic knowledge
Private or personalized training
If you have more than 8 people to sign up for a particular course, it can be delivered as a private session right at your offices. Contact us for more details.
Request a quoteDuration
5 days
Schedule
See training dates for details
Regular fee
$2,395
Preferential fee
A preferential rate is offered to public institutions, to members of certain professional organizations as well as to companies that do a certain amount of business with Technologia. To know more, please read the "Registration and rates" section on our FAQ page. Please note that preferential rates are not available for online training courses. Discounts cannot be combined with other offers.
$2,155
Private or personalized training
If you have more than 8 people to sign up for a particular course, it can be delivered as a private session right at your offices. Contact us for more details.
Request a quote