Analyze link, suggest learning program

Définir et appeler des méthodes avec des paramètres et des valeurs de retour.

Définir une classe avec des propriétés, des champs et des constructeurs.

Créer et utiliser des objets (instanciation, accès aux membres).

Appliquer l'encapsulation à l'aide des modificateurs d'accès (public, private).

Implémenter l'héritage entre les classes pour réutiliser le code.

Définir et implémenter des interfaces pour établir des contrats.

Appliquer le polymorphisme en surchargeant et en redéfinissant des méthodes.

Gérer les erreurs d'exécution à l'aide des blocs try-catch-finally.

Utiliser la collection Dictionary<TKey, TValue> pour stocker et récupérer des données par clé.

Définir et utiliser des classes et des méthodes génériques pour créer du code réutilisable.

Écrire des expressions lambda pour créer des fonctions anonymes concises.

Filtrer, transformer et trier des collections avec les méthodes LINQ de base (Where, Select, OrderBy).

Agréger et quantifier des données avec LINQ (Count, Sum, Any, FirstOrDefault).

Grouper les éléments d'une collection avec la méthode LINQ GroupBy.

Expliquer le principe de responsabilité unique (SRP) avec un exemple en C#.

Expliquer le principe ouvert/fermé (OCP) avec un exemple en C#.

Expliquer le principe de substitution de Liskov (LSP) avec un exemple en C#.

Expliquer le principe de ségrégation des interfaces (ISP) avec un exemple en C#.

Expliquer le principe d'inversion des dépendances (DIP).

Décrire le rôle de l'injection de dépendances (DI) dans l'application du principe DIP.

Reconnaître les violations courantes des principes SOLID dans des extraits de code.

Installer et configurer SQL Server Express LocalDB.

Identifier le rôle d'une base de données relationnelle dans une application web.

Écrire des requêtes SELECT pour extraire des données, en utilisant WHERE et ORDER BY.

Écrire une requête INSERT pour ajouter de nouvelles données dans une table.

Écrire des requêtes UPDATE et DELETE pour modifier et supprimer des données.

Identifier les relations entre les tables (un-à-plusieurs, plusieurs-à-plusieurs) à partir d'un schéma.

Écrire des requêtes JOIN pour combiner des données de plusieurs tables.

Créer un projet ASP.NET Core MVC et comprendre sa structure de fichiers.

Définir des contrôleurs et des méthodes d'action pour gérer les requêtes HTTP.

Créer des vues Razor pour afficher du contenu dynamique en utilisant la syntaxe de base.

Utiliser les Tag Helpers pour générer des éléments HTML courants (liens, formulaires).

Passer des données du contrôleur à la vue en utilisant des ViewModels.

Implémenter le 'model binding' pour récupérer les données d'un formulaire dans une action.

Valider les données d'un modèle avec les Data Annotations et afficher les messages d'erreur.

Comprendre et configurer le routage conventionnel pour mapper les URL aux actions.

Configurer Entity Framework Core dans un projet ASP.NET Core avec le fournisseur SQL Server.

Définir les classes d'entités qui représentent le modèle de données.

Configurer le DbContext pour enregistrer les entités et établir la connexion à la base de données.

Créer et appliquer des migrations pour générer et faire évoluer le schéma de la base de données.

Comprendre et utiliser async/await pour les opérations de base de données asynchrones.

Lire des données de manière asynchrone via le DbContext en utilisant des requêtes LINQ.

Ajouter, modifier et supprimer des données de manière asynchrone via le DbContext.

Configurer les relations entre les entités (un-à-plusieurs, un-à-un).

Créer une solution multi-projets suivant la Clean Architecture (Domain, Application, Infrastructure, Presentation).

Définir les entités métier et les interfaces de repository dans la couche Domain.

Implémenter le pattern Repository dans la couche Infrastructure en utilisant Entity Framework Core.

Configurer l'injection de dépendances dans ASP.NET Core pour lier les interfaces à leurs implémentations.

Définir les Data Transfer Objects (DTOs) et les interfaces de services dans la couche Application.

Implémenter les services applicatifs (cas d'utilisation) dans la couche Application.

Configurer AutoMapper pour mapper automatiquement entre les Entités, les DTOs et les ViewModels.

Implémenter le CRUD complet pour les produits en utilisant le pattern Repository et les services applicatifs.

Créer les contrôleurs et les vues pour afficher la liste des produits et les détails d'un produit.

Créer les formulaires de création et de modification des produits.

Implémenter le CRUD complet pour la gestion des catégories de produits.

Ajouter une fonctionnalité de recherche de produits par nom.

Mettre en œuvre un filtre pour afficher les produits par catégorie.

Sécuriser les fonctionnalités de gestion (CRUD produits/catégories) pour qu'elles ne soient accessibles qu'aux administrateurs.

Intégrer ASP.NET Core Identity pour la gestion des utilisateurs et des rôles.

Implémenter les pages d'inscription, de connexion et de déconnexion des utilisateurs.

Restreindre l'accès à certaines pages en utilisant l'attribut [Authorize] et les rôles.

Concevoir la structure de données du panier et implémenter l'ajout d'un produit.

Créer la vue du panier et implémenter la mise à jour des quantités et la suppression d'articles.

Implémenter le processus de passage de commande (checkout) et la sauvegarde en base de données.

Créer une page pour que les utilisateurs puissent consulter leur historique de commandes.

Créer un projet ASP.NET Core Web API et comprendre sa structure.

Implémenter des endpoints CRUD pour une ressource (ex: Produits) en suivant les conventions REST.

Utiliser les services applicatifs de la Clean Architecture pour alimenter les endpoints de l'API.

Documenter l'API en utilisant Swagger/OpenAPI.

Expliquer le fonctionnement de l'authentification par jeton JWT.

Configurer l'authentification JWT et créer un endpoint qui génère un jeton lors de la connexion.

Protéger les endpoints de l'API en exigeant un jeton JWT valide.

Tester les endpoints de l'API à l'aide d'un outil comme Postman ou l'interface Swagger.

Configurer un projet de test xUnit et écrire un premier test en utilisant le pattern Arrange-Act-Assert.

Écrire des tests unitaires pour la logique métier dans la couche Application.

Utiliser un framework de mock (ex: Moq) pour isoler les dépendances dans les tests unitaires.

Écrire des tests d'intégration pour les endpoints de l'API en utilisant WebApplicationFactory.

Créer un Dockerfile pour conteneuriser l'application ASP.NET Core.

Décrire les étapes clés pour déployer une application web sur une plateforme cloud comme Azure App Service.

Expliquer les concepts de base de l'Intégration Continue et du Déploiement Continu (CI/CD).