C# WinForms Store Data — Understanding Data Flow in a Windows Form with Tim Corey (Lesson 15)

Introducing the Create Tournament Form and Its Role

At 0:00, Tim Corey introduces Lesson 15 and explains that this Windows Form is a major turning point in the application. He notes that once this form is complete, the app will be mostly functional. Even though this form looks complex, Tim reassures developers that the system already supports most of the required features.

He emphasizes that by this point, earlier work—models, data connections, tables, and patterns—has already established a strong foundation. The goal now is to connect data to the form and make it work as a system, not as isolated controls.

Reviewing the Form and Fixing Early Issues

At 1:10, Tim explains that whenever he starts a Windows Form, he first reviews what the form does and breaks it into logical chunks. He immediately notices a small issue in the designer: two list boxes have the same label due to a copy-paste mistake.

Tim fixes the label text before moving forward, noting that small UI problems should be resolved early. This step reinforces that clean design and clarity matter just as much as code when data is being displayed to a user.

Planning Data Chunks and Flow

At 2:07, Tim outlines how he would normally approach this form if he were not recording a video. He explains that he would:

• Populate the Select Team dropdown

• Populate the selected teams list box

• Wire up the Add Team action

• Handle prizes

• Deal with create and delete actions later

Because this is a video lesson, Tim groups several chunks together. This planning step is critical because it defines how data will flow between collections, controls, and events inside the WinForms application.

Creating a Collection to Store Team Data

At 3:45, Tim switches to code view using F7, navigating through the Solution Explorer into the form’s code-behind file. He explains that the Select Team dropdown needs a collection of TeamModel objects.

He creates a Listcalled availableTeams. This list acts as the in-memory storage for data retrieved from the data source. Tim notes that for now it is initialized as a new list, but it will later be filled from either a database or a text file, depending on configuration.

This is a key moment where Tim shows that WinForms store data in collections, not directly in controls.

Defining the Data Retrieval Contract

At 5:01, Tim creates a method called GetTeamAll. He explains that this method matches patterns used earlier in the project, such as GetPersonAll. He adds it to the IDataConnection interface, calling it the contract that defines how data is retrieved.

He then implements this method in both the SQL and text connectors. Tim stresses consistency here, explaining that following established patterns makes the system easier to maintain and understand.

Working with Stored Procedures and Tables

At 6:32, Tim navigates to SQL Server and discusses stored procedures. He reviews existing procedures and explains why they are not suitable for this case. Since the tournament does not yet exist, he creates a new stored procedure named spTeam_GetAll.

This procedure:

• Takes no parameters

• Executes a simple select statement

• Retrieves all team records from the Teams table

Tim executes the procedure and verifies the data returned. This step ensures that the data source is working before binding it to the form.

Filling Related Data Using Loops

At 8:45, Tim explains that retrieving teams alone is not enough. Each team also contains a list of members, which are stored in a separate table. He shows how the TeamModel includes a TeamMembers collection that must be populated manually.

To do this, Tim loops through each team using a foreach loop. For every team instance, he calls another stored procedure that retrieves people by team ID. This process builds a fully populated model with related data.

Tim points out that this step ensures the application has complete data objects, not partial records.

Connecting Stored Data to the Windows Form

At 12:25, Tim returns to the Create Tournament Form and replaces the temporary list with a real data call using:

GlobalConfig.Connection.GetTeamAll()

This line retrieves data using the configured connection string and stores it in memory.

He then creates an InitializeLists method, which binds data to UI controls by setting:

• DataSource

• DisplayMember

Tim carefully selects TeamName as the display property, ensuring meaningful text is shown to the user instead of object references.

Debugging Errors and Verifying Data

At 15:17, Tim runs the application and encounters an error related to a missing parameter. He calmly reads the message, explaining that debugging is a normal part of development.

He fixes the issue by passing the required parameter and setting the command type to stored procedure. When the dropdown still appears empty, Tim investigates further.

At 22:35, he realizes that the InitializeLists method was never called. Once added to the constructor, the data is displayed correctly. Tim uses this moment to emphasize the importance of reviewing how pieces fit together in the system.

Managing Selected Teams in Memory

At 23:54, Tim creates another list called selectedTeams. This collection stores the teams chosen for the tournament. He explains that this pattern is identical to earlier forms in the project, reinforcing reuse and consistency.

He binds this list to another list box using the same display member, making it easy to show selected items.

Wiring Button Events and Moving Data

At 28:07, Tim double-clicks the Add Team button in the designer, generating the click event. He retrieves the selected item from the dropdown, casts it back into a TeamModel, and verifies it is not null.

He then removes the team from availableTeams, adds it to selectedTeams, and rebinds both lists. Tim explains that resetting the data source ensures the UI reflects changes immediately.

Wrapping Up Data Storage for This Lesson

At 32:13, Tim summarizes what has been accomplished:

• Data retrieved from the database

• Stored in collections

• Bound to WinForms controls

• Moved between lists

• Debugged and verified

He notes that the remaining work will build on this foundation.

Final Thoughts from Tim Corey

Tim closes the video by encouraging developers to keep practicing. He reminds viewers that understanding how data is stored, retrieved, and displayed in a C# WinForms application is essential for building reliable systems.

This lesson shows how developers deal with real data, real errors, and real workflows—step by step, exactly as Tim Corey demonstrates.