Guardar Datos de Torneos WinForms C# en una Base de Datos — Profundización con Tim Corey

Introducción

Desde el comienzo, Tim introduce la Lección 19 y explica que hoy finalmente es el día en que se completa el formulario Crear Torneo. Reconoce que este formulario ha sido uno de los más grandes hasta ahora, con muchas partes móviles que pueden sentirse abrumadoras. En esta lección, aprenderás cómo aplicar el modelo de eventos de WinForms y las características de desarrollo rápido de aplicaciones para completar un formulario del mundo real.

Tim tranquiliza a los espectadores de que la complejidad se ha dividido en piezas manejables y que el enfoque de hoy es la lógica final requerida para salvar los datos del torneo, ya sea a una base de datos SQL o un archivo de texto, y luego, la característica está completa. WinForms es ideal para el desarrollo rápido de aplicaciones (RAD) y la construcción de herramientas empresariales internas o utilidades ligeras, y su modelo de eventos relativamente simple y la vasta cantidad de recursos en línea facilitan su aprendizaje para nuevos desarrolladores.

Crear un nuevo proyecto en Visual Studio

Comenzar con una app de Windows Forms es sencillo con Visual Studio. Comienza abriendo Visual Studio y seleccionando "Crear un nuevo proyecto" desde la ventana de inicio. En el diálogo "Crear un nuevo proyecto", usa la barra de búsqueda para escribir "Windows Forms App"—esto rápidamente trae a la vista la plantilla que necesitas. Para reducir tus opciones, filtra por C# como el lenguaje y Windows como la plataforma.

Una vez has encontrado el tipo de proyecto "Windows Forms App (.NET Framework)", selecciónalo y haz clic en Siguiente. En la ventana "Configura tu nuevo proyecto", da un nombre a tu proyecto (por ejemplo, HelloWorld), elige una ubicación y luego haz clic en Crear. Visual Studio generará una nueva solución y abrirá tu formulario principal, que actúa como la interfaz gráfica de usuario para tu aplicación. Este formulario es donde diseñarás tu interfaz de usuario y añadirás controles, sentando las bases para tu aplicación de escritorio de Windows. La plantilla incluye todos los archivos necesarios y referencias al .NET Framework, por lo que puedes centrarte inmediatamente en construir las características y funcionalidades de tu app.

Revisando la lógica del botón Crear Torneo

Tim comienza con una revisión. Explica que todo comienza desde el botón Crear Torneo en el programa. En un programa de C# WinForms, se escriben manejadores de eventos para ejecutar código en respuesta a acciones de usuario específicas, como hacer clic en el botón Crear Torneo. Hasta este punto, la aplicación ya ha:

• Validado la entrada del usuario

• Construido el objeto torneo

• Creado rondas y enfrentamientos en memoria

La pieza faltante, explica Tim, es mantener esos datos. Previamente, la app podría guardar torneos, premios, y entradas, pero faltaba información de rondas. Eso es lo que esta lección corrige.

Guardando el torneo en SQL: una visión general

Tim navega hacia el método CreateTournament del conector SQL y recuerda a los espectadores que guardar datos sigue un patrón claro:

1. Guardar el torneo en sí mismo

2. Obtener el ID del torneo

3. Guardar premios

4. Ahorra entradas

5. Ahora: guarda rondas y emparejamientos

Nota: es importante seguir este orden de guardado para asegurar que todos los datos relacionados estén correctamente asociados y se mantenga la integridad de los datos de la aplicación.

Tim enfatiza que los patrones son buenos, y esta lección sigue el mismo patrón establecido anteriormente.

WinForms también admite la creación de elementos de UI reutilizables como botones, cuadros de texto y etiquetas, lo que ayuda a mantener la consistencia en la estructura de datos de la aplicación.

Comprendiendo la Complejidad de la Estructura de Datos

Aquí, Tim hace una pausa para explicar por qué guardar las rondas es más complejo.

• Un torneo tiene Rondas

• Cada ronda es una lista de MatchupModel

• Cada emparejamiento contiene objetos MatchupEntryModel

Tim explica que esto es una lista de una lista, y que esa complejidad es normal en esta etapa. Él anima a los espectadores a no asustarse—esto es solo un resultado natural del modelado de datos del mundo real.

También señala que las aplicaciones WinForms se construyen usando componentes, como rejillas de datos y controles de UI, que ayudan a los desarrolladores a crear aplicaciones de escritorio ricas en funcionalidades de manera eficiente. Todos los elementos visuales en la biblioteca de clases de Windows Forms se derivan de la clase Control, proporcionando una base consistente para construir y personalizar la interfaz de usuario.

Por Qué Importa el Orden de Guardado

Una de las explicaciones más críticas en el video ocurre aquí.

Tim explica que los datos deben guardarse en orden, porque:

• Una entrada de emparejamiento no puede ser guardada hasta que el ID del emparejamiento padre exista

• Una ronda no puede referenciar la siguiente ronda hasta que la anterior tenga IDs

Él explica que como los objetos refieren a las mismas direcciones de memoria, una vez que el ID se completa en un lugar, todas las referencias se actualizan automáticamente. Sin embargo, los desarrolladores pueden necesitar modificar referencias de objetos a medida que se asignan los IDs, lo cual es una parte típica del proceso dirigido por eventos en las aplicaciones WinForms de C# donde la aplicación responde a acciones del usuario y cambios de datos.

Asegurándose de que Todos los Modelos Tengan IDs

Tim señala una corrección importante: MatchupEntryModel aún no tiene una propiedad ID.

Incluso si no se necesita de inmediato, Tim lo añade de todas maneras, explicando que cada modelo respaldado por una base de datos debe tener un ID para consistencia y uso futuro. Por defecto, las aplicaciones Windows Forms usan archivos como Form1.Designer.cs para generar automáticamente el código de UI, asegurando una estructura y comportamiento estándar en la aplicación.

Dividiendo la Lógica en Pasos Simples

Esta sección sirve como un tutorial para guardar datos en una aplicación WinForms de C.

Tim utiliza una de sus analogías de enseñanza favoritas: comerse un elefante a mordiscos.

Él divide la lógica de guardado en pasos claros:

1. Recorre cada ronda

2. Dentro de cada ronda, recorre los emparejamientos

3. Guarda cada emparejamiento

4. Recorre las entradas de emparejamiento

5. Guarda cada entrada

Cada paso es simple por sí solo—y juntos, son poderosos.

El diseñador visual de arrastrar y soltar en Visual Studio hace que WinForms sea excelente para construir herramientas internas, prototipos y aplicaciones simples.

Recorriendo Rondas y Emparejamientos

Tim muestra cómo recorrer una lista de rondas, donde cada ronda a su vez es una lista de MatchupModel.

Intencionalmente evita 'var' al principio y explica por qué: los tipos explícitos ayudan a los desarrolladores a entender qué están recorriendo, especialmente cuando trabajan con listas anidadas. El código claro es especialmente importante cuando se trabaja con diferentes lenguajes de programación en el desarrollo de Windows Forms, ya que mejora la mantenibilidad y apoya la localización para múltiples idiomas.

También comparte una filosofía importante:

"El mejor código es aquel que un desarrollador junior puede entender."

Las aplicaciones Windows Forms están dirigidas por eventos y son soportadas por el .NET Framework de Microsoft.

Creando el Procedimiento Almacenado de Inserción de Emparejamientos

Tim cambia a SQL y crea spMatchups_Insert.

Él explica claramente los campos:

• ID del Torneo

• Ronda del Emparejamiento

• ID del Ganador (nullable)

Podrían incluirse campos adicionales, como la fecha, para rastrear cuándo ocurren los emparejamientos.

Tim deliberadamente no establece un ganador en esta etapa. Incluso si un emparejamiento es un bye, prefiere manejar a los ganadores más tarde usando la misma lógica que los partidos reales.

Windows Forms proporciona acceso a los controles de interfaz de usuario comunes de Windows nativos envolviendo la API de Windows existente en código administrado.

Guardando Entradas de Emparejamientos y Manejando NULLs

Tim crea otro procedimiento almacenado: spMatchupEntries_Insert.

Él explica:

• Las puntuaciones son NULL porque los juegos no se han jugado

• NULL no es lo mismo que cero

• TeamCompeting puede ser NULL en rondas posteriores

Él da un ejemplo memorable usando fútbol y golf para explicar por qué cero es un valor real, mientras que NULL significa que aún no existe un valor.

Las configuraciones de la aplicación pueden configurarse en su proyecto WinForms para manejar diferentes escenarios de datos, como cómo se muestran o procesan en controles los valores NULL.

Windows Forms está incluido como parte de Microsoft .NET, .NET Framework o Mono.

Características y Funcionalidad de una Aplicación .NET Framework

Una aplicación Windows Forms construida sobre el .NET Framework ofrece un potente conjunto de características para crear modernas aplicaciones de escritorio para Windows. Con Windows Forms (WinForms), tienes acceso a una rica biblioteca de interfaz gráfica de usuario (GUI) que facilita el diseño de interfaces de usuario intuitivas e interactivas. WinForms es un marco de código abierto gratuito incluido con Microsoft .NET, .NET Framework y Mono, proporcionando una integración perfecta con los controles nativos de Windows y la API de Windows a través de código administrado.

El IDE Visual Studio mejora tu experiencia de desarrollo con herramientas como el Diseñador de Windows Forms, que te permite arrastrar y soltar controles comunes—como botones, cuadros de texto y etiquetas—directamente en tu formulario. Este enfoque visual acelera el diseño de la UI y te permite personalizar propiedades y eventos usando la ventana de Propiedades. Con soporte incorporado para la edición de código, depuración y gestión de proyectos, Visual Studio agiliza el proceso de construir, probar y refinar tus aplicaciones de escritorio para Windows. Ya sea que estés creando herramientas de negocio, utilidades o software educativo, el .NET Framework y WinForms proporcionan una plataforma robusta para entregar aplicaciones ricas en funcionalidades, responsivas y fáciles de usar.

Depuración con Editar y Continuar

Cuando ocurre una excepción, Tim no entra en pánico—él enseña.

Utiliza la función Editar y Continuar de Visual Studio para:

• Pausar ejecución

• Insertar comprobaciones de null

• Reanudar ejecución sin reiniciar la aplicación

Los atajos de teclado, como usar combinaciones de 'Ctrl' (por ejemplo, 'Ctrl + Alt + X' para abrir la Caja de Herramientas), pueden acelerar la depuración y el acceso a los controles de UI en Visual Studio.

Él muestra cómo:

• Comprobar si TeamCompeting es null

• Pasar null a SQL en lugar de acceder a .ID

• Aplicar la misma lógica a ParentMatchup

Este es un flujo real de trabajo de depuración, exactamente como lo utiliza Tim.

Visual Studio ofrece una amplia gama de características y herramientas para el desarrollo en C#, incluyendo el Diseñador de Windows Forms.

Verificando los Datos en SQL

Después de corregir dos pequeños errores, Tim consulta la base de datos.

Él confirma:

• Los emparejamientos se guardan correctamente

• Los números de ronda son precisos

• La lógica de bye funciona

• Las relaciones padre-hijo son correctas

Observe las relaciones correctas y los datos en la base de datos después de guardar, ya que este feedback visual es importante para verificar que la lógica de la aplicación está funcionando como se pretende.

Tim señala que solo ocurrieron dos errores en una característica muy compleja—y atribuye ese éxito a la planificación, los patrones y a dividir el trabajo en pequeñas partes.

Windows Forms proporciona una plataforma para escribir aplicaciones de cliente para escritorio, laptops y tabletas, haciéndola una elección versátil para el desarrollo en Windows.

Compilando y Preparando Métodos de Consulta

Tim empieza asegurándose de que el proyecto aún compila antes de abordar las partes sin terminar. A las 1:17:08, él explica que el sistema pasará cadenas a los métodos y recibirá uno o más objetos MatchupEntryModel a cambio, extraídos de archivos de texto.

A las 1:17:40, Tim implementa un método llamado LookupTeamById(int id). Él explica que cuando los datos se almacenan en un archivo de texto, solo se guarda el ID, no el objeto completo. Por lo tanto, al cargar datos, la aplicación debe rehidratar ese ID de nuevo en un modelo completo TeamModel.

Tim señala que esta no es lógica nueva—simplemente reutiliza el mismo patrón ya usado para cargar todos los equipos desde el archivo. Él enfatiza que esta reutilización es intencional y un beneficio clave de estructurar el código adecuadamente. Los desarrolladores también pueden consultar métodos existentes y la documentación oficial para orientación adicional al implementar lógica similar.

Windows Forms es visto como un reemplazo para la anterior y más compleja Biblioteca de Clases Microsoft Foundation basada en C++ para el desarrollo de GUI.

Centralizando Rutas de Archivos con GlobalConfig

A las 1:20:27, Tim hace una pausa y señala un problema de diseño: los nombres de archivo están siendo pasados por todas partes, aunque son constantes. Él abiertamente dice que esto se siente "ridículo".

Para solucionar esto, Tim mueve las constantes de los nombres de archivo a GlobalConfig, haciéndolas públicas. A las 1:21:33, él explica que esto evita pasar rutas de archivo a través de múltiples capas de métodos. El Solution Explorer en Visual Studio ayuda a gestionar estos archivos de proyecto y la estructura general, haciendo más fácil localizar y actualizar tales constantes.

Sin embargo, a las 1:22:24, Tim es honesto sobre un defecto: estas constantes ahora existen en dos lugares—GlobalConfig y el TextConnector. Él explícitamente llama a esto una violación de DRY (No te Repitas a Ti Mismo) y señala que esto debería ser refactorizado más adelante, pero hoy no es ese día.

También es importante notar que Windows Forms no proporciona un marco de aplicación predeterminado como la Clase de Fundamentos de Microsoft (MFC).

Convirtiendo Cadenas en Modelos de Entrada de Emparejamiento

A las 1:24:37, Tim empieza implementando ConvertStringToMatchupEntryModel. Él explica que las entradas de emparejamiento se almacenan como IDs delimitados por tuberías, así que el primer paso es dividir la cadena en la tubería (|). A diferencia de las aplicaciones web que usan una página como un contenedor de UI principal para navegación y disposición, WinForms usa formularios para organizar la interfaz de usuario.

Para las 1:25:17, él recorre cada ID, lo busca desde el archivo de entrada del emparejamiento, y agrega el modelo correspondiente a una lista de salida. El patrón se mantiene consistente:

cargar → convertir → filtrar por ID → devolver modelo

Tim enfatiza que la consistencia hace posible la depuración más tarde.

Las aplicaciones Windows Forms pueden desarrollarse usando lenguajes de programación .NET como C# o Visual Basic.

Construyendo el Extensión ConvertToMatchupEntryModels

A las 1:27:56, Tim crea un método de extensión ConvertToMatchupEntryModels(List< string>). Para guiar el proceso, él copia un método de conversión existente (para PersonModel) y lo usa solo como referencia de patrón.

Para las 1:30:28, Tim asigna columnas explícitamente:

• Columna 0 → ID

• Columna 1 → ID del Equipo Compitiendo

• Columna 2 → Puntuación

• Columna 3 → ID del Emparejamiento Padre

Él explica que el valor almacenado es solo un ID, por lo que el objeto completo debe ser reconstruido usando métodos de búsqueda. Algunos componentes y temas de UI en WinForms están inspirados en Microsoft Office, como Office 2019 Colorful y Office 2019 Black, para proporcionar una experiencia de usuario familiar.

Vendedores de terceros como DevExpress ofrecen suites de componentes UI completas para WinForms.

Manejando Emparejamientos Padres de Forma Segura

A las 1:38:49, Tim identifica un problema importante: los emparejamientos padres pueden no existir (especialmente en la primera ronda). Llamar a First() en un ID que falta haría que la aplicación se caiga.

Su corrección a las 1:39:09 utiliza int.TryParse. Si la conversión falla, ParentMatchup se establece en null. Tim explica con cuidado que esto es exactamente lo que debería suceder para los emparejamientos de primera ronda. A menudo se incluyen nuevas características y correcciones en cada lanzamiento de WinForms o bibliotecas de terceros, mejorando cómo se manejan tales escenarios.

Él refuerza que las caídas son aceptables solo cuando el dato inválido nunca debería existir, como un ID de equipo inválido.

La Suscripción WinForms de DevExpress incluye más de 190 controles y bibliotecas de UI, proporcionando amplias opciones para construir aplicaciones robustas.

Guardando Emparejamientos y Entradas en Archivos

A las 1:44:00, Tim se mueve a guardar datos. Él carga todos los emparejamientos, determina el próximo ID disponible, lo asigna y luego se mueve a guardar las entradas de emparejamiento. Después de guardar tus datos, puedes probar la aplicación haciendo clic en el botón Inicio o presionando F5 en Visual Studio para ejecutar tu aplicación WinForms.

Para las 1:46:44, Tim resalta el poder de los métodos reutilizables—cargar y convertir archivos ahora es "aburrido", lo cual dice que es algo bueno.

Él guarda las entradas de emparejamiento primero para que cada entrada obtenga un ID, luego guarda el emparejamiento en sí, que almacena esos IDs de entrada como cadenas delimitadas por tuberías.

Además, la Suscripción WinForms de DevExpress incluye una suite de informes con un diseñador de informes de usuario final, lo que puede mejorar tus aplicaciones WinForms.

Escribiendo Entradas de Emparejamiento a la Base de Datos

A las 1:49:43, Tim construye la lógica de guardado línea por línea. Él cuidadosamente revierte el patrón de conversión anterior:

• ID

• TeamCompeting ID (o cadena vacía)

• Puntuación

• ParentMatchup ID (o cadena vacía)

Después de explicar la lógica de guardado, es importante notar que WinForms es compatible con varias plataformas .NET, lo que garantiza compatibilidad y actualizaciones continuas.

A las 1:52:02, Tim explica por qué las cadenas vacías son esenciales: preservan el orden de las columnas sin romper la lógica de análisis.

Además, los controles WinForms de DevExpress admiten la aceleración de hardware DirectX para mejorar el rendimiento.

Guardando enfrentamientos y ganadores

A las 1:55:02, Tim guarda los enfrentamientos en sí. Debido a que los enfrentamientos pueden tener múltiples entradas, convierte las listas de entradas en cadenas delimitadas por tuberías utilizando un método auxiliar reutilizado. Los desarrolladores pueden utilizar la caja de herramientas en Visual Studio para añadir controles como botones y etiquetas a sus formularios de Windows, facilitando el diseño de la interfaz de usuario.

A las 1:58:30, aplica la misma lógica de manejo de nulos para el campo de ganador. Si aún no existe un ganador, se guarda una cadena vacía.

Windows Forms permite a los desarrolladores crear aplicaciones para escritorios, tabletas y PCs.

Rehidratando rondas al cargar torneos

A las 2:02:03, Tim aborda el último TODO: cargar información de rondas. Explica que las rondas se almacenan como listas de IDs de enfrentamiento, divididas primero por tuberías y luego por acentos circunflejos (^).

Para las 2:09:13, reconstruye toda la estructura anidada completa:

• IDs → Modelos de Enfrentamiento

• Modelos de Enfrentamiento → Listas de Rondas

• Listas de Rondas → Modelo de Torneo

Después de explicar la reconstrucción, Tim señala que, a diferencia de otros marcos, WinForms utiliza un enfoque diferente para organizar la UI y los datos, lo que puede afectar cómo los desarrolladores gestionan las estructuras anidadas.

Tim enfatiza que esta anidación explica por qué el código parece complejo y por qué es tan importante recorrerlo manualmente.

Además, vale la pena mencionar que la suscripción DevExpress WinForms incluye temas personalizables y skins para aplicaciones WinForms.

Depurando errores reales

A partir de las 2:11:22, Tim ejecuta intencionadamente la aplicación y depura:

• NullReferenceException

• Cadena de entrada no está en el formato correcto

• La secuencia no contiene elementos

En lugar de ocultar errores, Tim muestra exactamente cómo rastrearlos, inspeccionar valores y reflexionar sobre el orden de ejecución. WinForms fue lanzado hace años y ha evolucionado con el tiempo.

A las 2:20:30, identifica un problema de guardado circular: los enfrentamientos necesitaban existir antes de que las entradas pudieran referenciarlos. Su solución es pragmática: guardar dos veces. Abiertamente admite que no es elegante, pero dice:

"El código que funciona es mejor que el código refactorizado que aún tiene un error."

Windows Forms ahora está disponible como un proyecto de código abierto for .NET Core en GitHub.

Implementando una aplicación de Windows Forms

Después de construir y probar tu aplicación de Windows Forms en Visual Studio, el siguiente paso es la implementación: poner tu aplicación a disposición de los usuarios. Visual Studio ofrece varias opciones de implementación, siendo ClickOnce una de las más convenientes para aplicaciones de escritorio de Windows. ClickOnce te permite publicar tu aplicación en una carpeta de red compartida, un servidor web o incluso un CD/DVD, facilitando la instalación para los usuarios finales.

Para implementar, simplemente utiliza las herramientas de publicación en Visual Studio para empaquetar tu aplicación. Antes de publicar, prueba minuciosamente tu aplicación usando las herramientas de depuración de Visual Studio para detectar y corregir cualquier error o problema en tu código. Una vez implementada, los usuarios pueden instalar tu aplicación ejecutando el archivo de configuración o haciendo clic en un acceso directo, y la aplicación se ejecutará, mostrando su interfaz gráfica de usuario para interacción inmediata. Ya sea que elijas ClickOnce, Windows Installer, o una herramienta de implementación de terceros, el proceso asegura que tus usuarios puedan acceder a toda la funcionalidad y características de tu aplicación de Windows Forms con molestias mínimas. Este proceso de implementación optimizado te ayuda a entregar aplicaciones de escritorio de Windows confiables y profesionales a tu audiencia.

Reflexiones Finales

Al final de esta lección, Tim Corey demuestra un sistema completo y funcional de persistencia de datos utilizando archivos de texto como base de datos. Más importante aún, muestra cómo surgen los errores en el mundo real, cómo los patrones guían las correcciones, y por qué entender el orden de ejecución es más importante que la perfección.

Esta lección no trata sobre bases de datos sofisticadas: se trata de pensar como un desarrollador.