Liaison de données WinForms expliquée par le visualiseur de tournoi de Tim Corey

Introduction

Dans la leçon 22 de la série C# App Start to Finish, Tim Corey commence à travailler sur le formulaire de Visualisation de Tournoi, en se concentrant fortement sur la liaison de données WinForms. Tim explique que cette leçon ne porte pas sur l'enregistrement de données dans des bases de données ou des fichiers texte—cela viendra plus tard. Au lieu de cela, tout l'objectif de cette vidéo est de câbler l'UI, de peupler les contrôles, et de comprendre comment les données se déplacent entre les modèles et les contrôles WinForms en utilisant la liaison de données.

Tim précise que la liaison de données WinForms peut sembler maladroite, déroutante, et parfois frustrante. À cause de cela, cette leçon devient une plongée pratique et approfondie sur le comportement réel de la liaison de données, ce qui la casse, et comment la réparer. En suivant le parcours de débogage de Tim, nous obtenons une compréhension réaliste et précieuse de la mécanique de la liaison WinForms.

Aperçu du formulaire du visualiseur de tournoi

Tim commence par décrire ce que le formulaire du visualiseur de tournoi est censé faire. Le formulaire affiche :

• Le nom du tournoi

• Un menu déroulant contenant les tours du tournoi

• Une liste affichant les matchs pour le tour sélectionné

• Les noms des équipes et les scores pour le match sélectionné

Tim souligne que toutes ces informations doivent rester synchronisées. Lorsqu'un tour change, les matchs doivent être mis à jour. Lorsqu'un match change, les noms des équipes et les scores doivent être mis à jour. Cette exigence guide toute la discussion autour de la liaison des données. Les contrôles liés à la même source de données, également appelés contrôles liés aux données, restent automatiquement synchronisés. Le contrôle BindingNavigator gère la liaison aux données en gardant toujours à jour le pointeur vers l'élément dans la liste des enregistrements. La classe CurrencyManager gère une collection de liaisons entre les contrôles de liste et un objet source de données, permettant le suivi des positions et des notifications de changement. Chaque contrôle lié, comme une TextBox ou une Label, est lié à la source de données via ces mécanismes pour garantir une synchronisation automatique.

Passer l'objet Tournoi dans le Formulaire

Tim explique que le formulaire du visualiseur de tournoi ne doit pas décider quel tournoi charger. Cette responsabilité revient au tableau de bord. Par conséquent, le formulaire du visualiseur de tournoi doit recevoir un TournamentModel via son constructeur.

Il montre comment l'objet tournoi passé est stocké dans un champ privé au niveau du formulaire, le rendant accessible à chaque méthode du formulaire. Cet objet tournoi devient la source unique de vérité pour toutes les opérations de liaison de données. Dans une liaison de données simple, un contrôle peut être lié à un seul élément de données, tel qu'une valeur d'une seule table de données, vous permettant d'afficher ou de modifier des points de données individuels. Le BindingSource peut être utilisé dans des scénarios de liaison simples et complexes.

Méthode de Chargement des Données du Formulaire

Tim introduit une méthode privée appelée LoadFormData. Cette méthode extrait les données du modèle du tournoi et les envoie aux contrôles de l'interface utilisateur.

Par exemple :

• L'étiquette du nom du tournoi obtient sa valeur directement à partir de tournament.TournamentName. Cela implique de définir la propriété d'un contrôle, comme la propriété texte d'un contrôle de type textbox, sur une valeur provenant de la source de données.

Tim souligne que c'est la forme la plus simple de liaison de données—assigner manuellement les valeurs—et c'est un bon point de départ avant de traiter des listes et des collections. La liaison simple connecte une seule propriété d'un contrôle à une seule valeur dans une source de données et affiche généralement un enregistrement à la fois.

Brancher le Bouton du Tableau de Bord

Tim explique comment modifier le tableau de bord afin que lorsqu'un utilisateur sélectionne un tournoi et clique sur "Charger le Tournoi", le formulaire du visualiseur de tournoi s'ouvre.

Ici, Tim convertit l'élément sélectionné du menu déroulant en un TournamentModel et le passe dans le formulaire du visualiseur. Il confirme que le branchement fonctionne en exécutant l'application et en voyant le nom du tournoi apparaître correctement.

Cela confirme que la transmission de base des objets et les mises à jour de l'interface utilisateur fonctionnent avant de passer à la liaison des listes.

Chargement des Tours dans un Menu Déroulant à partir d'une Source de Données

Maintenant Tim passe à la liaison des listes, en commençant par les tours du tournoi.

Il explique que les tours sont mieux représentés comme une liste d'entiers, et non de chaînes de caractères. Tim dit explicitement que ce choix facilite le travail car :

• Les entiers se lient proprement aux listes déroulantes

• Les entiers peuvent être récupérés sans analyse de chaîne

• La valeur sélectionnée peut être convertie directement en entier

Un contrôle ComboBox peut être lié à une table ou une liste donnée, vous permettant d'afficher et de sélectionner efficacement les données. Lors de la liaison d'un contrôle ComboBox, vous pouvez utiliser la propriété DisplayMember pour spécifier le champ qui est affiché à l'utilisateur, et la propriété ValueMember pour déterminer quel champ est utilisé comme valeur sous-jacente. De même, vous pouvez lier le contrôle DataGridView aux informations contenues dans une table de données.

Tim parcourt les tours du tournoi, extrait les numéros de tour uniques et les stocke dans une liste.

Brancher le Menu Déroulant des Tours avec la Liaison de Données

Tim introduit la première règle importante de liaison dans WinForms :

Toujours définir la source de données sur null avant de la réinitialiser.

Il efface la source de données du menu déroulant, puis assigne la liste des tours à celle-ci. Lorsque vous liez un contrôle à une source de données, si la source de données implémente des interfaces telles que INotifyCollectionChanged, le contrôle actualisera automatiquement son interface utilisateur lorsque les données changent. Cela garantit une synchronisation en temps réel entre les données et leur représentation visuelle. De plus, les modifications dans le contrôle de l'interface utilisateur ou la source de données sous-jacente mettent automatiquement à jour l'autre extrémité de la liaison en fonction de la configuration (unilatérale ou bidirectionnelle). Étant donné que les entiers se convertissent naturellement en chaînes de caractères, il explique qu'aucun DisplayMember n'est requis ici.

Tim montre ensuite une erreur courante—oublier d'appeler la méthode de chargement—et montre comment l'oubli d'un seul appel de méthode entraîne un menu déroulant vide.

Événements SelectedIndexChanged et Mises à Jour Dynamiques

Tim explique que WinForms repose fortement sur les événements, en particulier SelectedIndexChanged.

Il branche l'événement SelectedIndexChanged du menu déroulant des tours à une méthode qui charge les matchs pour le tour sélectionné. En liaison de données WinForms, un gestionnaire d'événements reçoit le paramètre objet sender, qui identifie quel contrôle a déclenché l'événement. Vous pouvez gérer les événements suivants, tels que Format et Parse, pour personnaliser la mise en forme et la validation des données ; les événements Format et Parse de la classe Binding permettent une mise en forme spéciale et une validation des données pendant le processus de liaison des données. D'autres contrôles peuvent également être liés et synchronisés via un traitement similaire des événements.

Tim préfère extraire la logique dans des méthodes d'assistance privées plutôt que de placer le code directement dans les gestionnaires d'événements. Il explique que cela garde le code réutilisable et propre.

Chargement des Matchs en Fonction du Tour Sélectionné

Tim récupère le tour sélectionné en convertissant l'élément sélectionné du menu déroulant en entier.

Il parcourt à nouveau les tours du tournoi, mais cette fois filtre les matchs où le tour du match est égal au tour sélectionné. Ces matchs sont placés dans une liste de matchs sélectionnés, qui devient la source de données pour la liste de matchs.

Cela introduit le défi de la liaison des listes d'objets complexes.

Créer une Propriété d'Affichage pour la Liaison

Tim explique que le modèle de match n'a pas de représentation en chaîne naturelle adaptée à l'affichage dans l'interface utilisateur.

Au lieu de forcer la logique dans l'interface utilisateur, Tim ajoute une propriété DisplayName en lecture seule au modèle. Cette propriété construit une chaîne comme :

Équipe A contre Équipe B

Si une équipe manque (semaine de repos ou tour futur), Tim retourne :

Match non encore déterminé

Les contrôles liés complexes, tels que DataGridView, prennent en charge des scénarios de liaison complexes où plusieurs éléments de données d'une table de données ou d'autres structures peuvent être affichés et édités. La liaison de données complexe vous permet de lier plus d'un élément de données à un contrôle, comme lier plusieurs colonnes ou lignes de la source d'enregistrement sous-jacente. ADO.NET fournit de nombreuses structures de données adaptées à la liaison, y compris DataTable, DataView, et d'autres structures, et Windows Forms prend en charge la liaison à plusieurs sources de données. La classe de liaison gère le lien logique entre les champs de la source de données et les propriétés des contrôles, et des interfaces telles que IBindingList, IEditableObject et INotifyPropertyChanged fournissent le tri, la notification de changement et le support de retour arrière. Vous pouvez définir des filtres par défaut sur les vues de données pour contrôler la façon dont les données sont affichées, et le contexte de liaison et le CurrencyManager déterminent finalement comment les contrôles de données liés sont synchronisés. La propriété BindingContext d'un formulaire Windows gère les objets CurrencyManager pour le formulaire, et chaque source de données a un seul objet CurrencyManager, qui garde tous les contrôles liés à la même source de données synchronisés. Des contrôles personnalisés peuvent être créés dans Windows Forms qui se comportent comme des contrôles standards liés aux données en implémentant les interfaces de liaison nécessaires.

C'est un principe clé de la liaison de données WinForms que Tim souligne :

Le modèle doit décider comment il est affiché—pas l'interface utilisateur.

Déboguer les Bugs de Liaison

Tim rencontre plusieurs bugs :

• Le deuxième tour ne s'affiche pas correctement

• Les matchs ne se rafraîchissent pas

• Les événements se déclenchent de manière inattendue

Plutôt que de cacher ces problèmes, Tim parcourt chaque étape de débogage. Il explique comment la liaison se casse lorsque les listes sont remplacées, même si la nouvelle liste contient des données valides.

Cela mène à une leçon critique sur WinForms.

Le code suivant démontre comment gérer les événements Format et Parse de la classe Binding pour fournir une mise en forme spéciale et une validation pendant le processus de liaison des données. L'événement de format et l'événement d'analyse peuvent être utilisés pour personnaliser la manière dont les données sont converties et validées entre l'interface utilisateur et la source de données.

BindingSource vs BindingList dans la Liaison de Données Windows Forms

Tim expérimente avec BindingSource, le plaçant entre le contrôle de l'interface utilisateur et les données. Il explique comment cela était autrefois l'approche recommandée, mais admet que cela introduit de la complexité et de la confusion. Le composant BindingSource agit comme un proxy entre une source de données et les contrôles Windows Forms, et il fonctionne avec diverses structures de données adaptées à la liaison, telles que DataTables, DataViews, BindingLists et tableaux.

Ensuite, il introduit BindingList, expliquant qu'il met automatiquement à jour les contrôles liés lorsque la liste change. Si la source de données implémente les interfaces appropriées, telles que INotifyCollectionChanged, la liaison de données dans Windows Forms prend en charge les mises à jour automatiques des contrôles lorsque les données sous-jacentes changent.

Cependant, Tim découvre une règle cruciale :

Vous ne devez PAS remplacer une BindingList par une nouvelle.

Au lieu de cela, vous devez :

• Vider la BindingList existante

• Ajouter les éléments de nouveau dedans

Remplacer la liste casse la connexion de la liaison.

Résoudre les Liaisons Cassées en Vider les Listes

Tim confirme la cause racine du problème de liaison :

• Attribuer un nouveau BindingList() déconnecte l'interface utilisateur

• Vider et réajouter les éléments préserve la liaison

Il met à jour les tours et les matchs pour utiliser ce modèle. Une fois appliqué de manière cohérente, l'interface utilisateur se met enfin à jour correctement.

Charger Manuellement les Sélections Initiales

Tim explique que WinForms ne déclenche pas automatiquement SelectedIndexChanged lorsque les éléments sont chargés.

Pour résoudre cela, il charge manuellement :

• Les matchs du tour 1 après le chargement des tours

• Sélectionne le premier match programmatiquement

Cela garantit que l'interface utilisateur s'initialise correctement sans nécessiter d'interaction utilisateur.

Résultat Final et Résumé de la Leçon

À la fin de la leçon, Tim confirme :

• Les tours se mettent à jour correctement

• Les matchs se mettent à jour correctement

• Les noms des équipes et les scores se chargent correctement

• Les semaines de repos et les tours futurs affichent un texte significatif

Il souligne que cette leçon n'était pas sur la perfection, mais sur la compréhension du fonctionnement réel de la liaison des données dans WinForms—including ses limites.

Tim conclut en expliquant que le score et le filtrage (comme "non joués seulement") seront traités dans la prochaine leçon, une fois qu'il y aura un véritable changement d'état à gérer.

Considérations Finales

La leçon 22 est un cours magistral sur la liaison de données pratique dans WinForms, non pas parce que tout fonctionne parfaitement, mais parce que Tim Corey parcourt chaque échec, correction et décision de conception en temps réel.

En suivant la vidéo de Tim, les développeurs acquièrent une compréhension réaliste de :

• Pourquoi la liaison WinForms semble fragile

• Comment BindingList fonctionne

• Pourquoi vider les listes est important

• Comment l'interface utilisateur et les modèles doivent interagir

Si vous avez déjà eu des difficultés avec la liaison de données WinForms, cette leçon—et les explications de Tim—font enfin comprendre le "pourquoi".