Construire un formulaire de tableau de bord C# WinForms

Introduction au Formulaire de Tableau de Bord

Au tout début, Tim introduit la leçon 21 et explique l'objectif : câbler le formulaire de tableau de bord du tournoi, qui sera le premier formulaire à se lancer lorsque l'application démarre.

Tim souligne que ce formulaire est volontairement simple. Il ne fait que quelques choses :

• Charge une liste de tournois existants

• Permet à l'utilisateur de sélectionner et charger un tournoi

• Permet à l'utilisateur de créer un nouveau tournoi

Il rassure les téléspectateurs que cette leçon ne sera ni longue ni trop complexe, mais elle abordera de nombreuses parties importantes du système.

Ce dont le Formulaire de Tableau de Bord Est Responsable

Tim explique que le formulaire de tableau de bord a deux responsabilités principales :

1. Charger les tournois existants dans une liste déroulante

2. Ouvrir d'autres formulaires en fonction des actions de l'utilisateur

Si un tournoi existe déjà, l'utilisateur peut le sélectionner et cliquer sur Charger le Tournoi (qui sera câblé plus tard). Si l'utilisateur souhaite créer un nouveau tournoi, il clique sur Créer un Tournoi, ce qui ouvre un formulaire qui existe déjà dans le projet.

À ce stade, Tim clarifie que le bouton Charger le Tournoi n'est pas encore câblé et sera traité dans une leçon ultérieure.

Créer la Liste de Tournois pour la Liste Déroulante

Après avoir sélectionné le modèle de projet C#, Visual Studio ouvre un formulaire pour concevoir l'interface utilisateur.

Tim passe au code sous-jacent du formulaire et explique que la liste déroulante a besoin d'une liste de support. Remarquez comment le formulaire apparaît dans le concepteur, prêt pour la personnalisation des UI. Étant donné que la liste déroulante est censée afficher les tournois, la liste de support doit être une List< TournamentModel>.

Il crée une liste privée appelée tournois et explique qu'au lieu de créer une nouvelle liste manuellement, les données devraient provenir de la connexion GlobalConfig, qui abstrait la source de données, que ce soit SQL ou des fichiers texte.

Tim tente ensuite d'appeler une méthode nommée GetTournament_All, constate qu'elle n'existe pas encore et explique que cette méthode doit être ajoutée à la couche d'accès aux données.

Ajouter GetTournament_All à la Couche de Données

Tim passe au connecteur SQL et implémente la méthode manquante GetTournament_All. Il explique que cette méthode renverra une liste d'objets TournamentModel.

Il copie un modèle existant utilisé ailleurs dans le projet et l'adapte pour les tournois. La différence clé est que cette méthode appelle une procédure stockée nommée :

spTournaments_GetAll

Tim explique que cette procédure stockée récupère uniquement les données de base du tournoi :

• ID

• Nom du tournoi

• Frais d'inscription

• Statut actif

Il note que bien que le TournamentModel comporte bien plus de propriétés, ceci n'est que la première étape.

Comprendre l'Hydratation Partielle des Modèles

Tim s'arrête pour expliquer un concept important : l'hydratation partielle.

Bien que le modèle de tournoi inclue des équipes, des prix et des manches, ces propriétés ne sont pas encore peuplées. À ce stade :

• Les équipes sont vides

• Les prix sont vides

• Les manches sont vides

Il est attendu que seules les propriétés de base du tournoi soient peuplées à ce moment, tandis que les entités connexes comme les équipes, les prix et les manches restent vides jusqu'à un chargement ultérieur.

Tim souligne que cela est intentionnel et que ces entités connexes doivent être peuplées après le chargement des enregistrements de base du tournoi.

Remplir les Prix pour Chaque Tournoi

Tim introduit une boucle foreach qui parcourt chaque tournoi retourné par la base de données.

Pour les prix, il explique que le processus est simple :

• Appeler une procédure stockée qui récupère les prix par ID de tournoi

• Assigner le résultat à T.Prizes

Il fait référence à la procédure stockée spPrizes_GetByTournament et explique qu'elle renvoie tous les prix associés à un tournoi donné.

Ce modèle—charger les données de base, puis charger les données enfant par ID—est quelque chose que Tim souligne comme récurrent dans toute l'application.

Chargement des Équipes et Membres des Équipes

Ensuite, Tim passe aux équipes entrées.

Il explique que le chargement des équipes est un processus en deux étapes :

1. Charger les équipes associées au tournoi

2. Pour chaque équipe, charger les membres de l'équipe

Il utilise une procédure stockée nommée spTeams_GetByTournament pour récupérer uniquement les équipes pertinentes pour le tournoi actuel.

Ensuite, pour chaque équipe, Tim réutilise une méthode existante pour charger les membres de l'équipe par ID de l'équipe. Il souligne que cela est presque identique au code déjà écrit plus tôt dans la série, juste adapté pour les données spécifiques au tournoi.

Introduction à la Complexité des Manches

Tim explique que les manches sont la partie la plus complexe du modèle de tournoi.

Les manches sont stockées sous la forme de :

List<List<MatchupModel>>

Pour les peupler, Tim a besoin de :

• Charger tous les affrontements pour le tournoi

• Charger les entrées d'affrontement pour chaque affrontement

• Résoudre des relations comme les affrontements parent et les gagnants

Il commence par revoir les procédures stockées :

• spMatchups_GetByTournament

• spMatchupEntries_GetByMatchup

Gestion des IDs de Gagnants et des Modèles Imbriqués

Tim indique un problème courant lors de la manipulation des bases de données : SQL renvoie des IDs, mais l'application attend des objets.

La propriété Gagnant est un TeamModel, mais la base de données ne renvoie qu'un WinnerId. Tim explique qu'il est impossible d'hydrater directement des objets imbriqués à partir de SQL.

Pour résoudre ce problème, il ajoute une propriété temporaire WinnerId au modèle, qui est utilisée uniquement pendant le chargement des données. Une fois toutes les équipes chargées, il utilise l'ID pour attribuer le bon TeamModel à la propriété Winner.

Peuplement des Entrées d'Affrontement et Affrontements Parents

Pour chaque affrontement, Tim :

• Charge les entrées d'affrontement par ID d'affrontement

• Vérifie les IDs d'équipe valides

• Utilise une liste mise en cache de toutes les équipes pour résoudre les relations

Il explique pourquoi les IDs par défaut valent 0 lorsqu'aucune valeur n'existe et pourquoi vérifier > 0 est essentiel.

Tim explique également comment les affrontements parents sont résolus en référant aux affrontements déjà chargés, en se basant sur le fait que les affrontements sont ordonnés par manche.

Construire la Structure des Manches

Une fois tous les affrontements entièrement peuplés, Tim explique comment les manches sont construites.

Il introduit :

• Une variable currentRound

• Une liste currentRow

Tandis qu'il parcourt les affrontements :

• Si le numéro de manche change, la manche précédente est ajoutée à T.Rounds

• Une nouvelle liste de manches est créée

• Les affrontements sont groupés en conséquence

Tim passe en revue un exemple complet pour s'assurer que la logique est claire et souligne que séparer les boucles rend le code plus facile à comprendre.

Câbler la Liste Déroulante du Tableau de Bord

Vous pouvez ajouter des contrôles communs tels que des étiquettes, des zones de texte et des listes déroulantes au formulaire en les faisant glisser depuis la boîte d'outils dans Visual Studio.

De retour dans le Formulaire de Tableau de Bord, Tim crée une méthode WireUpLists().

Il assigne :

• DataSource à la liste des tournois

• DisplayMember à TournamentName

Les étiquettes sont souvent utilisées pour décrire l'objectif de la liste déroulante, tandis que les zones de texte peuvent être utilisées pour la saisie de l'utilisateur dans le formulaire. Pour gérer les interactions utilisateur, vous pouvez double-cliquer sur un bouton dans le concepteur pour générer automatiquement un gestionnaire d'événements Click dans le fichier Form1.cs.

Il explique que c'est cela qui permet à la liste déroulante d'afficher des noms lisibles par les humains au lieu de références d'objet.

Tester les Connexions SQL et Fichiers Texte

Tim exécute l'application en utilisant les deux sources de données :

• La connexion au fichier texte fonctionne immédiatement

• La connexion SQL génère une erreur

Vous pouvez exécuter l'application en sélectionnant le bouton Démarrer ou en appuyant sur F5 dans Visual Studio.

Il passe en revue le message d'erreur, identifie que ce bug a été causé par des paramètres manquants, et note que de tels bugs sont courants lors de l'intégration de plusieurs sources de données. Ce bug a été corrigé en passant correctement l'ID de tournoi aux procédures stockées.

Après avoir corrigé à la fois les prix et les équipes, Tim confirme que les deux sources de données fonctionnent maintenant correctement. Identifier et corriger les bugs est une partie normale du processus de développement, surtout lors de l'intégration de plusieurs sources de données.

Câbler le Bouton Créer un Tournoi

Enfin, Tim câble le bouton Créer un Tournoi en gérant ses événements, notamment l'événement Click.

Il explique que l'écriture du code de gestion d'événements pour le bouton se fait dans le fichier code-behind (Form1.cs), pas dans le fichier Form1.Designer.cs. Le fichier Form1.Designer.cs génère automatiquement le code UI pour Windows Forms et ne doit pas être édité manuellement.

Le bouton se contente de :

• Créer une nouvelle instance du formulaire Créer un Tournoi

• Appeler Show()

Il discute des décisions de conception sur où l'utilisateur devrait aller après avoir créé un tournoi et explique pourquoi naviguer directement vers le visualiseur de tournoi a le plus de sens.

Conclusion et Prochaines Étapes

Tim conclut en résumant le travail effectué :

• Le tableau de bord charge des tournois

• La liste déroulante est correctement peuplée

• Le formulaire Créer un Tournoi s'ouvre avec succès

Il note que l'actualisation de la liste après la création d'un tournoi sera traitée plus tard.

Dans la prochaine leçon, Tim présente le Formulaire de Visualisation de Tournoi, où les manches, affrontements, scores et progression seront implémentés—donnant vie au système de tournoi. Les futures versions de cette leçon couvriront des fonctionnalités et améliorations supplémentaires, y compris des mises à jour liées aux nouvelles versions de WinForms et .NET.

Cette leçon montre comment un tableau de bord WinForms n'est pas seulement une UI, mais un point de coordination entre les modèles, l'accès aux données, et la navigation—quelque chose que Tim démontre soigneusement étape par étape.

WinForms reste très pertinent pour sa stabilité, sa vitesse de développement rapide, et son intégration profonde avec le système d'exploitation Windows.