Effectively structure a backend application with .NET and key design patterns.
.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.
Is it for you ?
Backend developers and scalable application architects in a .NET environment
Prerequisites
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.
What You'll Walk Away With
- ✓ Design maintainable .NET architectures using SOLID principles, layered structure, and best practices
- ✓ Implement dependency injection and patterns (Strategy, Factory, Command, CQRS) to reduce coupling
- ✓ Structure data access with Entity Framework, Dapper, and Repository and Unit of Work patterns
- ✓ Build robust REST APIs with ASP.NET including testing, validation, and error handling
- ✓ Deploy containerized applications using CI/CD pipelines and Kubernetes with integrated security practices
Training content
1 Introduction
- 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.
2 Weak coupling with Microsoft.Extensions.DependencyInjection
- 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.
3 Exchanging messages with the Command pattern
- 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.
4 Data Access and Transaction Management
- 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.
5 Creating a REST API with ASP.NET Mvc
- 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.
6 Creating an MVC web application with ASP.NET MVC
- 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.
7 Securing a web application
- 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.
8 Continuous integration and continuous delivery
- Review of .NET commands for creating a deliverable.
- The 12 Factor App methodology.
- OCI image creation.
- Deploying an OCI image on a Kubernetes orchestrator.
📌 Practical information
Our training sessions are offered in Montreal or Quebec City, in person or in a virtual classroom. Dates and locations are specified when you select your session below. If you have any questions, check out our FAQ.
