C# WinForms Daten speichern — Verständnis des Datenflusses in einer Windows-Form mit Tim Corey (Lektion 15)

Tim Corey

34m 39s

Das Speichern und Verwalten von Daten in einer C# WinForms-Anwendung geht über das einfache Platzieren von Steuerungen auf einem Bildschirm hinaus. Es geht darum, wie Daten aus einer Datenbank oder Datei in Modelle gelangen und dann innerhalb eines Windows-Forms gebunden, angezeigt und manipuliert werden. In Lektion 15 des Kurses "C# From Start to Finish" führt Tim Corey Entwickler durch diesen Prozess auf sehr praktische Weise, indem er das Create Tournament Form erstellt.

In diesem Artikel betrachten wir die Konzepte der C# WinForms-Datenspeicherung genauer, genau so, wie Tim sie in seinem Video erklärt. Wir navigieren durch seine Schritte in Visual Studio, folgen, wie er Daten abruft, sie an Steuerungen bindet, Probleme debuggt und Ergebnisse überprüft.

Vorstellung des Create Tournament Forms und seiner Rolle

Bei 0:00 stellt Tim Corey Lektion 15 vor und erklärt, dass dieses Windows-Formular ein entscheidender Wendepunkt in der Anwendung ist. Er stellt fest, dass die App, sobald dieses Formular abgeschlossen ist, größtenteils funktional sein wird. Obwohl dieses Formular komplex aussieht, beruhigt Tim die Entwickler, dass das System die meisten erforderlichen Funktionen bereits unterstützt.

Er betont, dass durch die bisher geleistete Arbeit — Modelle, Datenschnittstellen, Tabellen und Muster — bereits eine starke Grundlage geschaffen wurde. Das Ziel ist jetzt, Daten mit dem Formular zu verbinden und als System zu arbeiten, nicht als isolierte Steuerungen.

Überprüfung des Formulars und Behebung früherer Probleme

Bei 1:10 erklärt Tim, dass er, wann immer er ein Windows-Formular startet, zunächst überprüft, was das Formular tut, und es in logische Teile unterteilt. Er bemerkt sofort ein kleines Problem im Designer: Zwei Listenfelder haben aufgrund eines Kopieren-Einfüge-Fehlers denselben Beschriftungstext.

Tim korrigiert den Beschriftungstext, bevor er fortfährt, und weist darauf hin, dass kleinere UI-Probleme frühzeitig gelöst werden sollten. Dieser Schritt verstärkt, dass sauberes Design und Klarheit genauso wichtig sind wie der Code, wenn Daten einem Benutzer angezeigt werden.

Planen von Datenstücken und Fluss

Bei 2:07 umreißt Tim, wie er normalerweise an dieses Formular herangehen würde, wenn er kein Video aufnehmen würde. Er erklärt, er würde:

• Das Dropdown-Menü 'Team auswählen' ausfüllen

• Das ausgewählte Teams-Listenfeld ausfüllen

• Die Aktion 'Team hinzufügen' verknüpfen

• Preise bearbeiten

• Sich später mit Erstell- und Löschaktionen beschäftigen

Da dies eine Video-Lektion ist, gruppiert Tim mehrere Stücke zusammen. Dieser Planungsschritt ist kritisch, da er definiert, wie Daten zwischen Sammlungen, Steuerungen und Ereignissen innerhalb der WinForms-Anwendung fließen.

Erstellen einer Sammlung zum Speichern von Teamdaten

Bei 3:45 wechselt Tim mit F7 zur Codeansicht und navigiert durch den Lösungsexplorer in die code-behind-Datei des Formulars. Er erklärt, dass das Dropdown-Menü 'Team auswählen' eine Sammlung von TeamModel-Objekten benötigt.

Er erstellt eine Liste <TeamModel> namens availableTeams. Diese Liste dient als In-Memory-Speicher für Daten, die von der Datenquelle abgerufen werden. Tim stellt fest, dass es vorerst als neue Liste initialisiert wird, aber später entweder von einer Datenbank oder einer Textdatei gefüllt wird, abhängig von der Konfiguration.

Dies ist ein wichtiger Moment, in dem Tim zeigt, dass WinForms Daten in Sammlungen speichern, nicht direkt in Steuerungen.

Definition des Datenabrufvertrags

Bei 5:01 erstellt Tim eine Methode namens GetTeamAll. Er erklärt, dass diese Methode zu früher im Projekt verwendeten Mustern passt, wie GetPersonAll. Er fügt sie der IDataConnection-Schnittstelle hinzu und nennt es den Vertrag, der definiert, wie Daten abgerufen werden.

Er implementiert diese Methode dann sowohl im SQL- als auch im Textconnector. Tim betont hier Beständigkeit und erklärt, dass die Befolgung etablierter Muster das System leichter wartbar und verständlich macht.

Arbeiten mit gespeicherten Prozeduren und Tabellen

Bei 6:32 navigiert Tim zu SQL Server und erläutert gespeicherte Prozeduren. Er überprüft bestehende Prozeduren und erklärt, warum sie für diesen Fall nicht geeignet sind. Da das Turnier noch nicht existiert, erstellt er eine neue gespeicherte Prozedur namens spTeam_GetAll.

Diese Prozedur:

• Nimmt keine Parameter

• Führt eine einfache Select-Anweisung aus

• Ruft alle Teamdatensätze aus der Teams-Tabelle ab

Tim führt die Prozedur aus und überprüft die zurückgegebenen Daten. Dieser Schritt stellt sicher, dass die Datenquelle funktioniert, bevor sie an das Formular gebunden wird.

Füllen verwandter Daten mit Schleifen

Bei 8:45 erklärt Tim, dass das Abrufen von Teams allein nicht genügt. Jedes Team enthält auch eine Liste von Mitgliedern, die in einer separaten Tabelle gespeichert sind. Er zeigt, wie das TeamModel eine TeamMembers-Sammlung enthält, die manuell gefüllt werden muss.

Um dies zu tun, durchläuft Tim jede Team mit einer foreach-Schleife. Für jede Team-Instanz ruft er eine weitere gespeicherte Prozedur auf, die Personen anhand der Team-ID abruft. Dieser Prozess erstellt ein vollständig besetzes Modell mit verwandten Daten.

Tim weist darauf hin, dass dieser Schritt sicherstellt, dass die Anwendung vollständige Datenobjekte, nicht teilweise Datensätze hat.

Verbinden gespeicherter Daten mit dem Windows Form

Bei 12:25 kehrt Tim zum Create Tournament-Formular zurück und ersetzt die temporäre Liste durch einen echten Datenabruf mit:

GlobalConfig.Connection.GetTeamAll()

GlobalConfig.Connection.GetTeamAll()

Diese Zeile ruft Daten mit der konfigurierten Verbindungszeichenfolge ab und speichert sie im Speicher.

Er erstellt dann eine InitializeLists-Methode, die Daten an UI-Steuerelemente bindet, indem folgendermaßen eingestellt wird:

• Datenquelle

• Anzeigemitglied

Tim wählt sorgfältig TeamName als Anzeigeeigenschaft aus, um sicherzustellen, dass dem Benutzer bedeutungsvoller Text anstelle von Objektverweisen angezeigt wird.

Fehler beheben und Daten überprüfen

Bei 15:17 führt Tim die Anwendung aus und stößt auf einen Fehler im Zusammenhang mit einem fehlenden Parameter. Ruhig liest er die Nachricht, erklärt, dass Debugging ein normaler Teil der Entwicklung ist.

Er behebt das Problem, indem er den erforderlichen Parameter übergibt und den Befehlstyp auf gespeicherte Prozedur setzt. Wenn das Dropdown-Menü immer noch leer erscheint, untersucht Tim weiter.

Bei 22:35 erkennt er, dass die InitializeLists-Methode nie aufgerufen wurde. Sobald sie dem Konstruktor hinzugefügt wurde, werden die Daten korrekt angezeigt. Tim nutzt diesen Moment, um die Bedeutung der Überprüfung, wie die Teile im System zusammenpassen, zu betonen.

Verwalten ausgewählter Teams im Speicher

Bei 23:54 erstellt Tim eine weitere Liste namens selectedTeams. Diese Sammlung speichert die für das Turnier ausgewählten Teams. Er erklärt, dass dieses Muster identisch mit früheren Formularen im Projekt ist und die Wiederverwendung und Konsistenz verstärkt.

Er bindet diese Liste an ein weiteres Listenfeld mit demselben Anzeige-Member, was es einfach macht, ausgewählte Elemente anzuzeigen.

Verkabeln von Button-Ereignissen und Verschieben von Daten

Bei 28:07 doppelklickt Tim auf den Add Team-Button im Designer, um das Klickereignis zu generieren. Er ruft das ausgewählte Element aus dem Dropdown ab, wandelt es in ein TeamModel zurück und überprüft, ob es nicht null ist.

Dann entfernt er das Team aus availableTeams, fügt es zu selectedTeams hinzu und bindet beide Listen erneut. Tim erklärt, dass das Zurücksetzen der Datenquelle sicherstellt, dass die UI Änderungen sofort widerspiegelt.

Abschließen der Datenspeicherung für diese Lektion

Bei 32:13 fasst Tim zusammen, was erreicht wurde:

• Daten aus der Datenbank abgerufen

• In Sammlungen gespeichert

• An WinForms-Steuerelemente gebunden

• Zwischen Listen verschoben

• Debuggt und überprüft

Er merkt an, dass die verbleibende Arbeit auf dieser Grundlage aufbauen wird.

Abschließende Gedanken von Tim Corey

Tim schließt das Video ab, indem er Entwickler ermutigt, weiter zu üben. Er erinnert die Zuschauer daran, dass das Verständnis, wie Daten in einer C# WinForms-Anwendung gespeichert, abgerufen und angezeigt werden, entscheidend für den Aufbau zuverlässiger Systeme ist.

Diese Lektion zeigt, wie Entwickler mit realen Daten, echten Fehlern und wirklichen Arbeitsabläufen umgehen – Schritt für Schritt, genau wie Tim Corey es demonstriert.