Construyendo un Formulario de Panel de Control en WinForms C#

Introducción al Formulario del Tablero

Al comienzo, Tim presenta la Lección 21 y explica el objetivo: conectar el Formulario del Tablero de Torneo, que será el primer formulario que se lanzará cuando comience la aplicación.

Tim señala que este formulario es intencionalmente simple. Realiza solo unas pocas cosas:

• Carga una lista de torneos existentes

• Permite al usuario seleccionar y cargar un torneo

• Permite al usuario crear un nuevo torneo

Reasegura a los espectadores que esta no será una lección larga ni excesivamente compleja, pero sí tocará muchas partes importantes del sistema.

Para qué es responsable el Formulario del Tablero

Tim explica que el formulario del tablero tiene dos responsabilidades principales:

1. Cargar los torneos existentes en un desplegable

2. Abrir otros formularios basados en las acciones del usuario

Si ya existe un torneo, el usuario puede seleccionarlo y hacer clic en Cargar Torneo (que se conectará más tarde). Si el usuario desea crear un nuevo torneo, hace clic en Crear Torneo, lo cual abre un formulario que ya existe en el proyecto.

En este punto, Tim aclara que el botón Cargar Torneo aún no está conectado y se manejará en una lección posterior.

Creando la Lista de Torneos para el Desplegable

Después de seleccionar la plantilla de proyecto C#, Visual Studio abre un formulario para que diseñes la interfaz de usuario.

Tim cambia al código subyacente del formulario y explica que el desplegable necesita una lista de respaldo. Observa cómo aparece el formulario en el diseñador, listo para la personalización de la interfaz de usuario. Dado que el desplegable está destinado a mostrar torneos, la lista de respaldo debe ser una Lista< TournamentModel>.

Crea una lista privada llamada torneos y explica que en lugar de crear manualmente una nueva lista, los datos deben provenir de la conexión de GlobalConfig, que abstrae si la fuente de datos es SQL o archivos de texto.

Tim intenta llamar a un método nombrado GetTournament_All, nota que aún no existe y explica que este método debe agregarse a la capa de acceso a datos.

Agregando GetTournament_All a la Capa de Datos

Tim pasa al Conector SQL e implementa el método GetTournament_All faltante. Explica que este método devolverá una lista de objetos TournamentModel.

Copia un patrón existente utilizado en otra parte del proyecto y lo adapta para los torneos. La diferencia clave es que este método llama a un procedimiento almacenado llamado:

spTournaments_GetAll

Tim explica que este procedimiento almacenado recupera solo los datos básicos del torneo:

• ID

• Nombre del torneo

• Cuota de inscripción

• Estado activo

Señala que, aunque el TournamentModel contiene muchas más propiedades, este es solo el primer paso.

Entendiendo la Hidratación Parcial del Modelo

Tim se detiene para explicar un concepto importante: la hidratación parcial.

Aunque el modelo de torneo incluye equipos, premios y rondas, esas propiedades aún no están pobladas. En esta etapa:

• Los equipos están vacíos

• Los premios están vacíos

• Las rondas están vacías

Se espera que solo las propiedades base del torneo estén pobladas en este punto, mientras que las entidades relacionadas como equipos, premios y rondas permanecen vacías hasta una carga adicional.

Tim enfatiza que esto es intencional y que estas entidades relacionadas deben poblarse después de que se carguen los registros base del torneo.

Poblando Premios para Cada Torneo

Tim introduce un bucle foreach que itera sobre cada torneo devuelto de la base de datos.

Para los premios, explica que el proceso es simple:

• Llamar a un procedimiento almacenado que recupera premios por ID de torneo

• Asignar el resultado a T.Prizes

Hace referencia al procedimiento almacenado spPrizes_GetByTournament y explica que devuelve todos los premios asociados con un torneo dado.

Este patrón — cargar datos base y luego cargar datos secundarios por ID — es algo que Tim destaca como recurrente en toda la aplicación.

Cargando Equipos y Miembros de Equipo

A continuación, Tim pasa a los equipos introducidos.

Explica que cargar equipos es un proceso de dos pasos:

1. Cargar los equipos asociados con el torneo

2. Para cada equipo, cargar los miembros del equipo

Usa un procedimiento almacenado llamado spTeams_GetByTournament para recuperar solo los equipos relevantes para el torneo actual.

Luego, para cada equipo, Tim reutiliza un método existente para cargar miembros del equipo por ID de equipo. Señala que esto es casi idéntico al código ya escrito anteriormente en la serie, solo adaptado para datos específicos del torneo.

Introduciendo la Complejidad de las Rondas

Tim explica que las rondas son la parte más compleja del modelo del torneo.

Las rondas se almacenan como:

Lista<List<MatchupModel>>

Para poblarlas, Tim necesita:

• Cargar todos los enfrentamientos para el torneo

• Cargar entradas de enfrentamientos para cada enfrentamiento

• Resolver relaciones como enfrentamientos principales y ganadores

Comienza revisando los procedimientos almacenados:

• spMatchups_GetByTournament

• spMatchupEntries_GetByMatchup

Manejo de IDs de Ganadores y Modelos Anidados

Tim señala un problema común al trabajar con bases de datos: SQL devuelve IDs, pero la aplicación espera objetos.

La propiedad de Ganador es un TeamModel, pero la base de datos solo devuelve un WinnerId. Tim explica que no puedes hidratar objetos anidados directamente desde SQL.

Para solucionar esto, agrega una propiedad temporal de WinnerId al modelo, que solo se usa durante la carga de datos. Una vez que todos los equipos están cargados, usa el ID para asignar el TeamModel correcto a la propiedad Ganador.

Poblando Entradas de Enfrentamientos y Enfrentamientos Principales

Para cada enfrentamiento, Tim:

• Carga entradas de enfrentamientos por ID de enfrentamiento

• Verifica la validez de los IDs de equipo

• Usa una lista en caché de todos los equipos para resolver relaciones

Explica por qué los IDs predeterminados a 0 cuando no existe un valor y por qué es esencial verificar > 0.

Tim también explica cómo los enfrentamientos principales se resuelven haciendo referencia a enfrentamientos ya cargados, basándose en el hecho de que los enfrentamientos están ordenados por ronda.

Construyendo la Estructura de Rondas

Una vez que todos los enfrentamientos están completamente poblados, Tim explica cómo se construyen las rondas.

Introduce:

• Una variable currentRound

• Una lista currentRow

Mientras recorre los enfrentamientos:

• Si cambia el número de ronda, se agrega la ronda anterior a T.Rounds

• Se crea una nueva lista de rondas

• Los enfrentamientos se agrupan en consecuencia

Tim repasa un ejemplo completo para asegurar que la lógica esté clara y enfatiza que separar bucles hace que el código sea más fácil de entender.

Conectando el Desplegable del Tablero

Puede agregar controles comunes como etiquetas, cuadros de texto y desplegables al formulario arrastrándolos desde la Caja de Herramientas en Visual Studio.

De vuelta en el Formulario del Tablero, Tim crea un método WireUpLists().

Asigna:

• DataSource a la lista de torneos

• DisplayMember a TournamentName

Las etiquetas se usan a menudo para describir el propósito del desplegable, mientras que los cuadros de texto se pueden usar para la entrada del usuario en el formulario. Para manejar las interacciones del usuario, se puede hacer doble clic en un botón en el diseñador para generar automáticamente un controlador de eventos Click en el archivo Form1.cs.

Explica que esto es lo que hace que el desplegable muestre nombres legibles en lugar de referencias a objetos.

Probando Conexiones SQL y Archivos de Texto

Tim ejecuta la aplicación usando ambas fuentes de datos:

• La conexión de archivos de texto funciona inmediatamente

• La conexión SQL genera un error

Puedes ejecutar la aplicación seleccionando el botón de Inicio o presionando F5 en Visual Studio.

Camina a través del mensaje de error, identifica que este error fue causado por parámetros faltantes y señala que tales errores son comunes al integrar múltiples fuentes de datos. Este error se corrigió al pasar correctamente el ID del torneo a los procedimientos almacenados.

Después de corregir tanto premios como equipos, Tim confirma que ambas fuentes de datos ahora funcionan correctamente. Identificar y solucionar errores es una parte normal del proceso de desarrollo, especialmente al integrar múltiples fuentes de datos.

Conectando el Botón Crear Torneo

Finalmente, Tim conecta el botón Crear Torneo manejando sus eventos, específicamente el evento Click.

Explica que el código de manejo de eventos para el botón se escribe en el archivo de código subyacente (Form1.cs), no en el archivo Form1.Designer.cs. El archivo Form1.Designer.cs genera automáticamente el código de interfaz de usuario para los Windows Forms y no debe editarse manualmente.

El botón simplemente:

• Crea una nueva instancia del formulario Crear Torneo

• Llama a Show()

Discute las decisiones de diseño sobre a dónde debería ir el usuario después de crear un torneo y explica por qué navegar directamente al visor de torneos tiene más sentido.

Conclusión y Qué Sigue

Tim concluye resumiendo el trabajo realizado:

• El tablero carga torneos

• El desplegable se llena correctamente

• El formulario Crear Torneo se abre exitosamente

Señala que la actualización de la lista después de crear un torneo se manejará más adelante.

En la próxima lección, Tim presenta el Formulario Visor de Torneos, donde se implementarán rondas, enfrentamientos, puntuaciones y progresión, dando vida al sistema de torneos. Las versiones futuras de esta lección cubrirán características y mejoras adicionales, incluidas las actualizaciones relacionadas con nuevas versiones de WinForms y .NET.

Esta lección muestra cómo un tablero de WinForms no es solo una interfaz de usuario, sino un punto de coordinación entre modelos, acceso a datos y navegación, algo que Tim demuestra cuidadosamente paso a paso.

WinForms sigue siendo altamente relevante por su estabilidad, velocidad de desarrollo rápida e integración profunda con el sistema operativo Windows.