Développement d'application C#: Un aperçu approfondi de « Créer le formulaire d'équipe Partie 2 » de Tim Corey (Leçon 13)

Continuer le formulaire Create Team

Tim commence par nous rappeler que la leçon 13 est une continuation de la vidéo précédente, où la section "Add New Member" a été raccordée. Dans cette leçon, Tim explique que l'objectif principal est de connecter le menu déroulant (combo box) et la liste box, puis de connecter le nouvel objet person créé pour qu'il apparaisse dans la liste. Tim établit clairement le plan : cette leçon se concentrera sur le raccordement de l'IU, le mouvement des données et la synchronisation des listes - des aspects fondamentaux pour créer une application de bureau C#.

Comprendre les données des listes déroulantes et box

Tim explique que derrière la combo box et la list box, il y aura une liste d'objets Person. C'est un exemple classique de liaison de données dans Windows Forms, où les éléments d'IU sont liés à des collections de modèles de données.

Il crée deux listes privées au niveau de la classe :

• availableTeamMembers – les personnes qui peuvent être ajoutées à l'équipe

• selectedTeamMembers – les personnes déjà ajoutées à l'équipe

Tim clarifie le comportement attendu : lorsqu'une personne est sélectionnée dans le menu déroulant et ajoutée, elle doit passer de availableTeamMembers à selectedTeamMembers. C'est un modèle d'opération CRUD standard dans le développement d'applications de bureau, où l'IU reflète les données sous-jacentes.

Pourquoi Tim ne limite pas les membres de l'équipe par tournoi

Tim aborde une question fréquente de conception : "Pourquoi ne pas restreindre les membres de l'équipe en fonction du tournoi ?" Il explique que le formulaire Create Team n'est pas directement lié à un tournoi, et que plusieurs tournois peuvent se dérouler simultanément.

Tim utilise un exemple pratique : si un tournoi de basket-ball et un tournoi de ping-pong se déroulent tous les deux, une personne pourrait y participer. Limiter le menu déroulant nécessiterait une logique complexe et pourrait introduire des bogues. Au lieu de cela, Tim choisit une approche plus simple :

• Seulement supprimer une personne du menu déroulant après qu'elle a été ajoutée à une équipe.

Cette approche démontre une décision de conception logicielle pratique : éviter les sur-complications si ce n'est pas nécessaire.

Créer la méthode WireUpLists

Tim crée une méthode appelée WireUpLists pour connecter les listes aux contrôles de l'IU. Cette méthode lie la liste availableTeamMembers à la boîte de combinaison et la liste selectedTeamMembers à la liste de sélection.

Tim souligne une amélioration clé : dans les formulaires Windows modernes, vous pouvez lier des listes directement aux contrôles sans utiliser une source de liaison distincte. C'est un conseil utile pour les développeurs travaillant sur la liaison de données dans Windows Forms.

Ajouter un DisplayMember avec Nom complet

Tim explique que la boîte de combinaison doit afficher un nom lisible. La propriété DisplayMember attend une propriété de chaîne du modèle Person. Tim avertit qu'utiliser uniquement FirstName ou LastName peut causer des doublons.

Ainsi, Tim crée une propriété en lecture seule appelée FullName :

public string NomComplet
{
    get
    {
        return $"{Prenom} {Nom}";
    }
}

Cela démontre une pratique importante de l'interface utilisateur : assurez-vous toujours que votre interface affiche des informations conviviales, pas des données d'objet brutes.

Créer des données d'exemple pour tester

Tim crée une méthode appelée CreateSampleData pour tester les listes et l'interface utilisateur. Il ajoute des objets Person d'exemple aux deux listes et appelle WireUpLists dans le constructeur.

C'est une technique utile pour construire et tester rapidement des applications Windows Forms avant de se connecter à une base de données réelle.

Remplacer les données d'exemple par des données réelles

Tim commente les données d'exemple et se prépare à charger les données réelles. Il ajoute une méthode GetPerson_All à l'interface IDataConnection. Tim explique sa convention de nommage :

• Créer = insérer

• Obtenir = sélectionner

C'est une stratégie de nommage standard pour les couches d'accès aux données dans les applications C#.

Implémentation de la récupération de données SQL avec Dapper

Tim implémente la version SQL de GetPerson_All en utilisant Dapper et une procédure stockée :

connection.Query<PersonModel>("spPeople_GetAll").ToList();

Tim utilise intentionnellement une variable de sortie au lieu d'un retour direct pour faciliter le débogage. Cela démontre comment les pratiques de débogage peuvent affecter la conception du code.

Nettoyer le code répété avec des constantes

Tim remarque des noms de chaînes de connexion répétés et les change en une constante. Il explique que la répétition est une mauvaise pratique et peut causer des erreurs plus tard.

C'est un principe important de l'ingénierie logicielle : DRY (Don't Repeat Yourself).

Charger des données réelles dans la liste déroulante

Tim crée LoadListData() et remplit availableTeamMembers en utilisant GetPerson_All(). La liste selectedTeamMembers reste vide, ce qui est correct puisque une nouvelle équipe commence vide.

Cela démontre comment connecter l'interface utilisateur à de réelles sources de données, qu'il s'agisse d'une base de données ou d'un fichier texte.

Connecter le bouton Ajouter un membre

Tim crée le gestionnaire d'événement du bouton Ajouter un membre. La logique est :

1. Récupérer la personne sélectionnée dans la liste déroulante

2. La retirer de la liste disponible

3. La rajouter à la liste sélectionnée

4. Actualiser l'interface utilisateur

Tim explique que l'élément sélectionné doit être converti en PersonModel car la boîte de combinaison stocke des objets en tant qu'objet. Cela met en évidence l'importance de la conversion de types et de la gestion des objets en C#.

Déboguer le problème d'actualisation

Tim découvre que l'interface utilisateur ne s'actualise pas après avoir déplacé des éléments. Après débogage, il trouve la solution :

• Définir DataSource sur null

• Puis réassigner la liste

Cela force la boîte de combinaison et la liste de sélection à s'actualiser. Tim souligne que les compétences en débogage sont essentielles et souvent nécessaires pour comprendre comment le lien de données se comporte.

Connecter le bouton Supprimer sélectionné

Tim renomme le bouton en Supprimer sélectionné et crée le gestionnaire d'événements. Cela inverse l'opération d'ajout :

• Retirer de selectedTeamMembers

• Ajouter de nouveau à availableTeamMembers

• Actualiser l'interface utilisateur

Tim découvre un bug : si aucun élément n'est sélectionné, une valeur null est ajoutée. Il ajoute une validation :

if (p != null)
{
    // procéder
}

Cela démontre la validation de base et la prévention des erreurs.

L'importance des tests

Tim insiste sur le fait de tester votre application comme un utilisateur qui essaie de la casser. Il conseille d'avoir des testeurs qui essaient intentionnellement de casser l'application, car les utilisateurs réels feront des actions inattendues.

C'est une leçon clé pour construire un logiciel fiable.

Connecter le bouton " Créer un membre "

Tim modifie le bouton " Créer un membre " pour enregistrer une nouvelle personne dans le stockage de données et l'ajouter immédiatement à la liste sélectionnée. Cela démontre comment implémenter des opérations CRUD dans une application Windows Forms.

Implémenter GetPerson_All pour les fichiers texte

Tim se rend compte que la version fichier texte de GetPerson_All manque. Il l'implémente en utilisant une ligne simple :

return PeopleFile.FullFilePath.LoadFile().ConvertToPersonModels();

Cela montre que le stockage basé sur des fichiers peut être implémenté facilement sans logique complexe.

Confirmer que tout fonctionne

Tim exécute l'application et confirme que la liste déroulante charge maintenant les personnes depuis le fichier texte et la base de données. Il ajoute de nouvelles personnes et les voit apparaître immédiatement, montrant que le système complet fonctionne correctement.

Et ensuite ?

Tim conclut en déclarant que la prochaine vidéo se concentrera sur la création de l'équipe elle-même. Cela implique de sauvegarder plusieurs morceaux de données dans la base de données ou un fichier texte, complétant la fonctionnalité.

Conclusion

La leçon 13 de Tim Corey est un exemple concret du développement d'application Windows Forms en C#. De la connexion des contrôles d'interface utilisateur et de la liaison de données au débogage et à la validation, Tim enseigne des compétences de programmation pratiques pour créer de véritables applications de bureau. Cette leçon est particulièrement précieuse pour les développeurs qui veulent apprendre la liaison de données, Dapper, les opérations CRUD SQL, et la programmation orientée interface utilisateur en C#.

Si vous souhaitez continuer à apprendre, la prochaine leçon de Tim complétera la fonctionnalité de création d'équipe et intégrera le tout dans une application fonctionnelle.