Stockage des données dans C# WinForms — Comprendre le flux de données dans un formulaire Windows avec Tim Corey (Leçon 15)

Présentation du formulaire Create Tournament et son rôle

À 0:00, Tim Corey présente la leçon 15 et explique que ce formulaire Windows est un tournant majeur dans l'application. Il note qu'une fois ce formulaire terminé, l'application sera principalement fonctionnelle. Bien que ce formulaire semble complexe, Tim rassure les développeurs que le système supporte déjà la plupart des fonctionnalités requises.

Il souligne qu'à ce stade, le travail antérieur—modèles, connexions de données, tables, et modèles—a déjà établi une base solide. L'objectif maintenant est de connecter les données au formulaire et de le faire fonctionner en tant que système, et non comme des contrôles isolés.

Revue du formulaire et résolution des premiers problèmes

À 1:10, Tim explique que chaque fois qu'il commence un formulaire Windows, il examine d'abord ce que fait le formulaire et le découpe en segments logiques. Il remarque immédiatement un petit problème dans le concepteur : deux boîtes à liste ont la même étiquette en raison d'une erreur de copier-coller.

Tim corrige le texte de l'étiquette avant d'avancer, notant que les petits problèmes d'interface utilisateur doivent être résolus tôt. Cette étape renforce que la propreté du design et la clarté importent autant que le code lorsque des données sont affichées à un utilisateur.

Planification des segments de données et du flux

À 2:07, Tim décrit comment il aborderait normalement ce formulaire s'il n'enregistrait pas une vidéo. Il explique qu'il :

• Remplirait la liste déroulante Select Team

• Remplirait la boîte à liste des équipes sélectionnées

• Connecterait l'action Add Team

• Gérerait les prix

• S'occuperait des actions de création et de suppression plus tard

Parce que c'est une leçon vidéo, Tim regroupe plusieurs segments ensemble. Cette étape de planification est critique car elle définit comment les données circuleront entre les collections, les contrôles et les événements dans l'application WinForms.

Créer une collection pour stocker les données de l'équipe

À 3:45, Tim passe à la vue code en utilisant F7, naviguant à travers l'Explorateur de solutions dans le fichier de code-behind du formulaire. Il explique que la liste déroulante Select Team a besoin d'une collection d'objets TeamModel.

Il crée une List appelée availableTeams. Cette liste agit comme le stockage en mémoire pour les données récupérées de la source de données. Tim note que pour l'instant elle est initialisée comme une nouvelle liste, mais elle sera ensuite remplie à partir d'une base de données ou d'un fichier texte, selon la configuration.

C'est un moment clé où Tim montre que les WinForms stockent les données dans des collections, et non directement dans les contrôles.

Définir le contrat de récupération des données

À 5:01, Tim crée une méthode appelée GetTeamAll. Il explique que cette méthode correspond aux modèles utilisés plus tôt dans le projet, comme GetPersonAll. Il l'ajoute à l'interface IDataConnection, l'appelant le contrat qui définit comment les données sont récupérées.

Il implémente ensuite cette méthode dans les connecteurs SQL et texte. Tim souligne la cohérence ici, expliquant que suivre des modèles établis rend le système plus facile à maintenir et à comprendre.

Travailler avec les procédures stockées et les tables

À 6:32, Tim se rend sur SQL Server et discute des procédures stockées. Il passe en revue les procédures existantes et explique pourquoi elles ne conviennent pas pour ce cas. Étant donné que le tournoi n'existe pas encore, il crée une nouvelle procédure stockée nommée spTeam_GetAll.

Cette procédure :

• Ne prend pas de paramètres

• Exécute une simple instruction select

• Récupère tous les enregistrements d'équipe de la table Teams

Tim exécute la procédure et vérifie les données retournées. Cette étape assure que la source de données fonctionne avant de la lier au formulaire.

Remplir les données connexes en utilisant des boucles

À 8:45, Tim explique que récupérer des équipes seules ne suffit pas. Chaque équipe contient également une liste de membres, qui sont stockés dans une table séparée. Il montre comment le TeamModel inclut une collection TeamMembers qui doit être remplie manuellement.

Pour ce faire, Tim parcourt chaque équipe en utilisant une boucle foreach. Pour chaque instance d'équipe, il appelle une autre procédure stockée qui récupère les personnes par ID d'équipe. Ce processus construit un modèle entièrement peuplé avec des données connexes.

Tim souligne que cette étape garantit que l'application dispose d'objets de données complets, et non de enregistrements partiels.

Connexion des données stockées au formulaire Windows

À 12:25, Tim retourne au formulaire Create Tournament et remplace la liste temporaire par un appel de données réel en utilisant :

GlobalConfig.Connection.GetTeamAll()

Cette ligne récupère les données en utilisant la chaîne de connexion configurée et les stocke en mémoire.

Il crée ensuite une méthode InitializeLists, qui lie les données aux contrôles de l'interface utilisateur en définissant :

• Source de données

• Membre à afficher

Tim sélectionne soigneusement TeamName comme propriété d'affichage, garantissant que du texte significatif est montré à l'utilisateur au lieu de références d'objet.

Déboguer les erreurs et vérifier les données

À 15:17, Tim exécute l'application et rencontre une erreur liée à un paramètre manquant. Il lit calmement le message, expliquant que le débogage est une partie normale du développement.

Il corrige le problème en passant le paramètre requis et en définissant le type de commande sur la procédure stockée. Lorsque la liste déroulante semble toujours vide, Tim enquête davantage.

À 22:35, il réalise que la méthode InitializeLists n'a jamais été appelée. Une fois ajoutée au constructeur, les données sont affichées correctement. Tim utilise ce moment pour souligner l'importance de revoir comment les pièces s'assemblent dans le système.

Gérer les équipes sélectionnées en mémoire

À 23:54, Tim crée une autre liste appelée selectedTeams. Cette collection stocke les équipes choisies pour le tournoi. Il explique que ce modèle est identique aux formulaires précédents dans le projet, renforçant la réutilisation et la cohérence.

Il lie cette liste à une autre boîte à liste en utilisant le même membre d'affichage, rendant facile l'affichage des éléments sélectionnés.

Connecter les événements de bouton et déplacer les données

À 28:07, Tim double-clique sur le bouton Add Team dans le concepteur, générant l'événement de clic. Il récupère l'élément sélectionné de la liste déroulante, le retransforme en TeamModel, et vérifie qu'il n'est pas nul.

Il supprime ensuite l'équipe de availableTeams, l'ajoute à selectedTeams, et relie les deux listes à nouveau. Tim explique que réinitialiser la source de données assure que l'interface utilisateur reflète les changements immédiatement.

Conclure le stockage des données pour cette leçon

À 32:13, Tim résume ce qui a été accompli :

• Données récupérées de la base de données

• Stockées dans les collections

• Liées aux contrôles WinForms

• Déplacées entre les listes

• Déboguées et vérifiées

Il note que le travail restant s'appuiera sur cette fondation.

Réflexions finales de Tim Corey

Tim termine la vidéo en incitant les développeurs à continuer de pratiquer. Il rappelle aux spectateurs que comprendre comment les données sont stockées, récupérées et affichées dans une application C# WinForms est essentiel pour construire des systèmes fiables.

Cette leçon montre comment les développeurs traitent des données réelles, des erreurs réelles et des flux de travail réels-étape par étape, exactement comme le démontre Tim Corey.