Sauvegarder les données de tournoi C# WinForms dans une base de données — Une analyse approfondie avec Tim Corey

Introduction

Au tout début, Tim présente la leçon 19 et explique qu'aujourd'hui est enfin le jour où le formulaire Créer un tournoi est terminé. Il reconnaît que ce formulaire a été l'un des plus grands jusqu'à présent, avec de nombreuses parties mobiles qui peuvent sembler écrasantes. Dans cette leçon, vous apprendrez comment appliquer le modèle basé sur les événements de WinForms et les fonctionnalités de développement rapide pour terminer un formulaire du monde réel.

Tim rassure les spectateurs que la complexité a été divisée en morceaux gérables et que l'objectif d'aujourd'hui est la logique finale nécessaire pour sauvegarder les données de tournoi, soit dans une base de données SQL soit dans un fichier texte, et ensuite la fonctionnalité est terminée. WinForms est idéal pour le développement rapide d'applications (RAD) et la construction d'outils métier internes ou d'utilitaires légers, et son modèle basé sur les événements relativement simple et son abondance de ressources en ligne le rendent facile à apprendre pour les nouveaux développeurs.

Créer un nouveau projet dans Visual Studio

Commencer avec une application Windows Forms est simple avec Visual Studio. Commencez par ouvrir Visual Studio et sélectionnez " Créer un nouveau projet " depuis la fenêtre de démarrage. Dans le dialogue " Créer un nouveau projet ", utilisez la barre de recherche pour taper " Application Windows Forms " - cela fait rapidement apparaître le modèle dont vous avez besoin. Pour affiner vos options, filtrez par C# comme langage et Windows comme plateforme.

Une fois que vous avez trouvé le type de projet " Application Windows Forms (.NET Framework) ", sélectionnez-le et cliquez sur Suivant. Dans la fenêtre " Configurer votre nouveau projet ", donnez à votre projet un nom (par exemple, HelloWorld), choisissez un emplacement, puis cliquez sur Créer. Visual Studio générera une nouvelle solution et ouvrira votre formulaire principal, qui sert d'interface utilisateur graphique pour votre application. Ce formulaire est l'endroit où vous concevez votre interface utilisateur et ajoutez des contrôles, posant les bases de votre application de bureau Windows. Le modèle inclut tous les fichiers nécessaires et les références au .NET Framework, vous permettant de vous concentrer sur la construction des fonctionnalités et de la fonctionnalité de votre application sans délai.

Révision de la logique du bouton Créer un tournoi

Tim commence par une révision. Il explique que tout commence par le bouton Créer un tournoi dans le programme. Dans un programme C# WinForms, des gestionnaires d'événements sont écrits pour exécuter du code en réponse à des actions spécifiques de l'utilisateur, telles que cliquer sur le bouton Créer un tournoi. Jusqu'à présent, l'application a déjà :

• Validé la saisie utilisateur

• A construit l'objet tournoi

• Créé des tours et des confrontations en mémoire

La pièce manquante, explique Tim, est de conserver ces données. Auparavant, l'application pouvait enregistrer des tournois, des prix et des inscriptions, mais les informations de tour n'étaient pas disponibles. C'est ce que cette leçon corrige.

Enregistrer le tournoi dans SQL : La vue d'ensemble

Tim se rend à la méthode CreateTournament du connecteur SQL et rappelle aux spectateurs que l'enregistrement des données suit un schéma clair :

1. Enregistrer le tournoi lui-même

2. Obtenir l'ID du tournoi

3. Enregistrer les prix

4. Enregistrer les inscriptions

5. Maintenant : enregistrer les tours et les confrontations

Remarque : Il est important de suivre cet ordre d'enregistrement pour s'assurer que toutes les données associées sont correctement liées et que l'intégrité des données de l'application est maintenue.

Tim souligne que les schémas sont bons et que cette leçon suit le même schéma établi précédemment.

WinForms prend également en charge la création d'éléments d'interface utilisateur réutilisables tels que les boutons, les champs de texte et les étiquettes, ce qui aide à maintenir la cohérence dans la structure des données de l'application.

Comprendre la complexité de la structure de données

Ici, Tim fait une pause pour expliquer pourquoi l'enregistrement des tours est plus complexe.

• Un tournoi a des Tours

• Chaque tour est une liste de MatchupModel

• Chaque confrontation contient des objets MatchupEntryModel

Tim explique qu'il s'agit d'une liste de liste, et que cette complexité est normale à ce stade. Il encourage les spectateurs à ne pas paniquer — ceci est simplement le résultat naturel de la modélisation de données du monde réel.

Il note également que les applications WinForms sont construites à l'aide de composants, tels que des grilles de données et des contrôles d'interface utilisateur, qui aident les développeurs à créer efficacement des applications de bureau riches en fonctionnalités. Tous les éléments visuels de la bibliothèque de classes Windows Forms dérivent de la classe Control, fournissant une base cohérente pour construire et personnaliser l'interface utilisateur.

Pourquoi l'ordre d'enregistrement est important

L'une des explications les plus critiques de la vidéo se passe ici.

Tim explique que les données doivent être enregistrées dans l'ordre, car :

• Une entrée de confrontation ne peut pas être enregistrée tant que l'ID de la confrontation parente n'existe pas

• Un tour ne peut pas référencer le tour suivant tant que le précédent n'a pas d'ID

Il explique que parce que les objets référencent les mêmes adresses mémoire, une fois que l'ID est peuplé à un endroit, toutes les références se mettent à jour automatiquement. Cependant, les développeurs peuvent avoir besoin de modifier les références d'objet à mesure que les IDs sont assignés, ce qui fait partie typique du processus événementiel dans les applications C# WinForms où l'application répond aux actions des utilisateurs et aux changements de données.

S'assurer que tous les modèles ont des IDs

Tim souligne une correction importante : MatchupEntryModel n'a pas encore de propriété ID.

Même si ce n'est pas immédiatement nécessaire, Tim l'ajoute quand même, expliquant que chaque modèle supporté par une base de données devrait avoir un ID pour la consistence et une utilisation future. Par défaut, les applications Windows Forms utilisent des fichiers comme Form1.Designer.cs pour générer automatiquement du code UI, assurant une structure et un comportement standardisés dans l'application.

Diviser la logique en étapes simples

Cette section sert de didacticiel pour enregistrer des données dans une application C WinForms.

Tim utilise l'une de ses analogies d'enseignement préférées : manger un éléphant une bouchée à la fois.

Il divise la logique d'enregistrement en étapes claires :

1. Boucler à travers chaque tour

2. À l'intérieur de chaque tour, boucler à travers les confrontations

3. Enregistrer chaque confrontation

4. Boucler à travers les entrées de confrontation

5. Enregistrer chaque entrée

Chaque étape est simple en soi — et ensemble, elles sont puissantes.

Le concepteur visuel simple de glisser-déposer dans Visual Studio fait de WinForms un excellent choix pour créer des outils internes, des prototypes et des applications simples.

Parcourir les tours et les confrontations

Tim montre comment parcourir une liste de tours, où chaque tour est lui-même une liste de MatchupModel.

Il évite intentionnellement d'utiliser var au début et explique pourquoi : les types explicites aident les développeurs à comprendre ce qu'ils parcourent, spécialement quand ils travaillent avec des listes imbriquées. Un code clair est particulièrement important lorsque l'on travaille avec différents langages de programmation dans le développement Windows Forms, car il améliore la maintenabilité et soutient la localisation pour plusieurs langues.

Il partage également une philosophie importante :

" Le meilleur code est celui qu'un développeur junior peut comprendre. "

Les applications Windows Forms sont orientées événement et soutenues par le .NET Framework de Microsoft.

Créer la procédure stockée d'insertion de confrontations

Tim passe à SQL et crée spMatchups_Insert.

Il explique clairement les champs :

• ID du tournoi

• Tour de la confrontation

• ID du gagnant (nullable)

Des champs supplémentaires, tels que la date, pourraient être inclus pour suivre quand les confrontations ont lieu.

Tim ne définit délibérément pas de gagnant à ce stade. Même si une confrontation est un bye, il préfère gérer les gagnants plus tard en utilisant la même logique que pour les matchs réels.

Windows Forms fournit un accès aux contrôles communs de l'interface utilisateur native de Windows en enveloppant l'API Windows existante dans du code géré.

Enregistrer les entrées de confrontation et gérer les NULLs

Tim crée une autre procédure stockée : spMatchupEntries_Insert.

Il explique :

• Les scores sont NULL car les jeux n'ont pas été joués

• NULL n'est pas équivalent à zéro

• TeamCompeting peut être NULL dans les tours suivants

Il donne un exemple mémorable en utilisant le football et le golf pour expliquer pourquoi zéro est une valeur réelle, alors que NULL signifie qu'aucune valeur n'existe encore.

Les paramètres d'application peuvent être configurés dans votre projet Windows Forms pour gérer différents scénarios de données, tels que comment les valeurs NULL sont affichées ou traitées dans les contrôles.

Windows Forms est inclus comme partie de Microsoft .NET, .NET Framework, ou Mono.

Fonctionnalités et fonctionnalités d'une application .NET Framework

Une application Windows Forms construite sur le .NET Framework offre un ensemble puissant de fonctionnalités pour créer des applications de bureau modernes pour Windows. Avec Windows Forms (WinForms), vous avez accès à une riche bibliothèque d'interface utilisateur graphique (GUI) qui facilite la conception d'interfaces utilisateur intuitives et interactives. WinForms est un framework gratuit et open-source inclus avec Microsoft .NET, .NET Framework et Mono, fournissant une intégration transparente avec les contrôles natifs Windows et l'API Windows via du code géré.

L'IDE Visual Studio améliore votre expérience de développement avec des outils tels que le Windows Forms Designer, qui vous permettent de glisser-déposer des contrôles courants — tels que des boutons, des champs de texte et des étiquettes — directement sur votre formulaire. Cette approche visuelle accélère la conception de l'interface utilisateur et vous permet de personnaliser les propriétés et les événements à l'aide de la fenêtre Propriétés. Avec un support intégré pour l'édition de code, le débogage et la gestion de projets, Visual Studio simplifie le processus de construction, de test et de raffinement de vos applications de bureau pour Windows. Que vous créiez des outils professionnels, utilitaires ou logiciels éducatifs, le .NET Framework et WinForms fournissent une plateforme robuste pour délivrer des applications riches en fonctionnalités, réactives et conviviales.

Débogage avec Éditer et Continuer

Lorsqu'une exception se produit, Tim ne panique pas — il enseigne.

Il utilise la fonctionnalité Éditer et Continuer de Visual Studio pour :

• Mettre en pause l'exécution

• Insérer des vérifications de nullité

• Reprendre l'exécution sans redémarrer l'application

Les raccourcis clavier, tels que l'utilisation des combinaisons 'Ctrl' (par exemple, 'Ctrl + Alt + X' pour ouvrir la boîte à outils), peuvent accélérer le débogage et l'accès aux contrôles UI dans Visual Studio.

Il montre comment :

• Vérifier si TeamCompeting est null

• Passer null à SQL au lieu d'accéder à .ID

• Appliquer la même logique à ParentMatchup

C'est un flux de travail de débogage réel, exactement comme Tim l'utilise.

Visual Studio offre une large gamme de fonctionnalités et d'outils pour le développement C#, y compris le Windows Forms Designer.

Vérifier les données dans SQL

Après avoir corrigé deux petits bugs, Tim interroge la base de données.

Il confirme :

• Les confrontations sont enregistrées correctement

• Les numéros de tour sont précis

• La logique de bye fonctionne

• Les relations parent-enfant sont correctes

Remarquer les relations correctes et les données dans la base de données après enregistrement, car ce retour visuel est important pour vérifier que la logique de l'application fonctionne comme prévu.

Tim souligne que seulement deux erreurs se sont produites dans une fonctionnalité très complexe — et crédite ce succès à la planification, aux schémas, et au travail divisé en petites parties.

Windows Forms offre une plateforme pour écrire des applications clientes pour bureaux, portables, et tablettes PCs, en en faisant un choix polyvalent pour le développement Windows.

Compiler et préparer les méthodes de recherche

Tim commence par s'assurer que le projet compile encore avant de s'attaquer aux parties non terminées. À 1:17:08, il explique que le système passera des chaînes dans les méthodes et recevra un ou plusieurs objets MatchupEntryModel en retour, tirés de fichiers texte.

À 1:17:40, Tim implémente une méthode appelée LookupTeamById(int id). Il explique que lorsque les données sont stockées dans un fichier texte, seul l'ID est enregistré, pas l'objet complet. Par conséquent, lors du chargement des données, l'application doit réhydrater cet ID en un TeamModel complet.

Tim souligne que ceci n'est pas une nouvelle logique — il réutilise simplement le même schéma déjà utilisé pour charger toutes les équipes à partir du fichier. Il souligne que cette réutilisation est intentionnelle et un avantage central de structurer correctement le code. Les développeurs peuvent également se référer aux méthodes existantes et à la documentation officielle pour des conseils supplémentaires lors de l'implémentation d'une logique similaire.

Windows Forms est vu comme un remplacement pour la bibliothèque complexe de classes de la Fondation Microsoft basée sur C++ pour le développement d'interfaces utilisateur.

Centraliser les chemins de fichiers avec GlobalConfig

À 1:20:27, Tim fait une pause et signale un problème de conception : les noms de fichier sont passés partout, même si ce sont des constantes. Il dit ouvertement que cela paraît " ridicule ".

Pour corriger cela, Tim déplace les constantes de nom de fichier dans GlobalConfig, en les rendant publiques. À 1:21:33, il explique que cela évite de passer des chemins de fichiers à travers plusieurs couches de méthodes. L'Explorateur de solutions dans Visual Studio aide à gérer ces fichiers de projet et la structure globale, rendant plus facile la localisation et la mise à jour de telles constantes.

Cependant, à 1:22:24, Tim est honnête quant à une faille : ces constantes existent maintenant dans deux endroits — GlobalConfig et le TextConnector. Il appelle explicitement cela une violation de DRY (Ne vous répétez pas) et note que cela devrait être refactoré plus tard, mais aujourd'hui n'est pas ce jour.

Il est également important de noter que Windows Forms ne fournit pas un framework d'application par défaut comme les Classes de la Fondation Microsoft (MFC).

Convertir des chaînes en modèles d'entrée de confrontation

À 1:24:37, Tim commence à implémenter ConvertStringToMatchupEntryModel. Il explique que les entrées de confrontation sont stockées sous forme d'IDs délimités par des pipes, donc la première étape consiste à diviser la chaîne sur le pipe (|). Contrairement aux applications web qui utilisent une page comme conteneur d'interface utilisateur principal pour la navigation et la mise en page, WinForms utilise des formulaires pour organiser l'interface utilisateur.

À 1:25:17, il parcourt chaque ID, le cherche dans le fichier d'entrée de confrontation, et ajoute le modèle correspondant à une liste de sortie. Le schéma reste cohérent :

charger → convertir → filtrer par ID → retourner le modèle

Tim souligne que la cohérence rend le débogage possible plus tard.

Les applications Windows Forms peuvent être développées en utilisant les langages de programmation .NET tels que C# ou Visual Basic.

Construire l'extension ConvertToMatchupEntryModels

À 1:27:56, Tim crée une méthode d'extension ConvertToMatchupEntryModels(List< string>). Pour guider le processus, il copie une méthode de conversion existante (pour PersonModel) et l'utilise purement comme référence de schéma.

À 1:30:28, Tim mappe explicitement les colonnes :

• Colonne 0 → ID

• Colonne 1 → TeamCompeting ID

• Colonne 2 → Score

• Colonne 3 → ParentMatchup ID

Il explique que la valeur stockée est juste un ID, donc l'objet complet doit être reconstruit en utilisant des méthodes de recherche. Certains composants et thèmes UI dans WinForms sont inspirés par Microsoft Office, tels que Office 2019 Colorful et Office 2019 Black, pour offrir une expérience utilisateur familière.

Des vendeurs tiers comme DevExpress offrent des suites de composants UI complètes pour WinForms.

Gérer les confrontations parentes en toute sécurité

À 1:38:49, Tim identifie un problème majeur : les confrontations parentes peuvent ne pas exister (surtout pour le premier tour). Appeler First() sur un ID manquant ferait planter l'application.

Sa correction à 1:39:09 utilise int.TryParse. Si l'analyse échoue, ParentMatchup est défini sur null. Tim explique soigneusement que c'est exactement ce qui devrait se produire pour les confrontations du premier tour. De nouvelles fonctionnalités et corrections sont souvent incluses dans chaque version de WinForms ou des bibliothèques tierces, améliorant la façon dont ces scénarios sont gérés.

Il renforce que les plantages sont acceptables seulement lorsque des données invalides ne devraient jamais exister, comme un ID d'équipe invalide.

L'abonnement DevExpress WinForms inclut plus de 190 contrôles UI et bibliothèques, offrant des options étendues pour construire des applications robustes.

Enregistrer les confrontations et les entrées dans des fichiers

À 1:44:00, Tim passe à la sauvegarde des données. Il charge toutes les confrontations, détermine l'ID disponible suivant, l'assigne, puis se concentre sur la sauvegarde des entrées de confrontation. Après avoir enregistré vos données, vous pouvez tester l'application en cliquant sur le bouton Démarrer ou en appuyant sur F5 dans Visual Studio pour exécuter votre application WinForms.

À 1:46:44, Tim met en évidence la puissance des méthodes réutilisables—charger et convertir des fichiers est maintenant " ennuyeux ", ce qui selon lui est une bonne chose.

Il sauvegarde d'abord les entrées de confrontation afin que chaque entrée obtienne un ID, puis sauvegarde la confrontation elle-même, qui stocke ces IDs d'entrée en tant que chaînes délimitées par des tuyaux.

De plus, l'abonnement DevExpress WinForms inclut une suite de rapports avec un concepteur de rapport utilisateur final, qui peut renforcer vos applications WinForms.

Écriture des entrées de confrontation dans la base de données

À 1:49:43, Tim construit la logique de sauvegarde ligne par ligne. Il inverse soigneusement le modèle de conversion précédent :

• ID

• ID de l'équipe concurrente (ou chaîne vide)

• Score

• ID du ParentMatchup (ou chaîne vide)

Après avoir expliqué la logique de sauvegarde, il est important de noter que WinForms est supporté sur diverses plateformes .NET, garantissant compatibilité et mises à jour continues.

À 1:52:02, Tim explique pourquoi les chaînes vides sont essentielles : elles préservent l'ordre des colonnes sans casser la logique d'analyse.

De plus, les contrôles DevExpress WinForms prennent en charge l'accélération matérielle DirectX pour une performance améliorée.

Enregistrer les confrontations et les vainqueurs

À 1:55:02, Tim enregistre les confrontations elles-mêmes. Parce que les confrontations peuvent avoir plusieurs entrées, il convertit les listes d'entrées en chaînes délimitées par des tuyaux en utilisant une méthode d'assistance réutilisée. Les développeurs peuvent utiliser la boîte à outils dans Visual Studio pour ajouter des contrôles tels que des boutons et des étiquettes à leurs Windows Forms, facilitant la conception de l'interface utilisateur.

À 1:58:30, il applique la même logique de gestion des valeurs nulles pour le champ du vainqueur. Si aucun vainqueur n'existe encore, une chaîne vide est enregistrée.

Windows Forms permet aux développeurs de créer des applications pour ordinateurs de bureau, tablettes et PC.

Réhydrater les rounds lors du chargement des tournois

À 2:02:03, Tim aborde le dernier À FAIRE : charger les informations des rounds. Il explique que les rounds sont stockés en tant que listes d'IDs de confrontations, d'abord séparés par des tuyaux, puis par des chevrons (^).

À 2:09:13, il reconstruit la structure imbriquée complète :

• IDs → MatchupModels

• MatchupModels → Listes de rounds

• Listes de rounds → TournamentModel

Après avoir expliqué la reconstruction, Tim note que, contrairement à certains autres frameworks, WinForms utilise une approche différente pour organiser l'interface utilisateur et les données, ce qui peut affecter la gestion des structures imbriquées par les développeurs.

Tim souligne que cet emboîtement explique pourquoi le code semble complexe — et pourquoi il est si important de le parcourir manuellement.

De plus, il convient de mentionner que l'abonnement DevExpress WinForms comprend des thèmes personnalisables et des skins pour les applications WinForms.

Débogage des véritables erreurs

À partir de 2:11:22, Tim exécute intentionnellement l'application et procède au débogage :

• NullReferenceException

• Chaîne d'entrée non dans le bon format

• La séquence ne contient aucun élément

Plutôt que de cacher les erreurs, Tim montre exactement comment les tracer, inspecter les valeurs et réfléchir à l'ordre d'exécution. WinForms a été publié pour la première fois il y a des années et a évolué au fil du temps.

À 2:20:30, il identifie un problème circulaire de sauvegarde : les confrontations devaient exister avant que les entrées puissent les référencer. Sa solution est pragmatique — sauvegarder deux fois. Il admet ouvertement que ce n'est pas élégant, mais dit :

" Un code fonctionnant est meilleur qu'un code refactorisé qui contient encore un bug. "

Windows Forms est désormais disponible en tant que projet open-source for .NET Core sur GitHub.

Déploiement d'une application Windows Forms

Après avoir construit et testé votre application Windows Forms dans Visual Studio, l'étape suivante est le déploiement—rendre votre application disponible pour les utilisateurs. Visual Studio offre plusieurs options de déploiement, ClickOnce étant l'une des plus pratiques pour les applications de bureau Windows. ClickOnce vous permet de publier votre application sur un partage de fichiers réseau, un serveur web, ou même un CD/DVD, rendant l'installation simple pour les utilisateurs finaux.

Pour déployer, utilisez simplement les outils de publication dans Visual Studio pour empaqueter votre application. Avant de publier, testez soigneusement votre application à l'aide des outils de débogage de Visual Studio pour détecter et corriger toute erreur ou problème dans votre code. Une fois déployée, les utilisateurs peuvent installer votre application en exécutant le fichier d'installation ou en cliquant sur un raccourci, et l'application s'exécutera, affichant son interface utilisateur graphique pour une interaction immédiate. Que vous choisissiez ClickOnce, Windows Installer, ou un outil de déploiement tiers, le processus garantit que vos utilisateurs peuvent accéder à la pleine fonctionnalité et aux caractéristiques de votre application Windows Forms avec un minimum de tracas. Ce processus de déploiement simplifié vous aide à livrer des applications de bureau Windows fiables et professionnelles à votre audience.

Considérations Finales

À la fin de cette leçon, Tim Corey démontre un système complet de persistance de données fonctionnant en utilisant des fichiers texte comme base de données. Plus important encore, il montre comment des bugs réels apparaissent, comment des motifs guident les corrections, et pourquoi comprendre l'ordre d'exécution est plus important que la perfection.

Cette leçon ne parle pas de bases de données sophistiquées — elle parle de penser comme un développeur.