Salvando Dados de Torneio em WinForms C# para um Banco de Dados — Um Mergulho Profundo com Tim Corey

Introdução

No início, Tim apresenta a Lição 19 e explica que hoje finalmente é o dia em que o formulário Criar Torneio é concluído. Ele reconhece que este formulário tem sido um dos maiores até agora, com muitas partes móveis que podem parecer avassaladoras. Nesta lição, você aprenderá a aplicar o modelo de evento-driven do WinForms e os recursos de desenvolvimento de aplicativos rápidos para concluir um formulário do mundo real.

Tim tranquiliza os espectadores que a complexidade foi dividida em partes gerenciáveis e que o foco de hoje é a lógica final necessária para salvar dados de torneios — seja em um banco de dados SQL ou em um arquivo de texto — e então o recurso está concluído. WinForms é ideal para desenvolvimento rápido de aplicativos (RAD) e criação de ferramentas comerciais internas ou utilitários leves, e seu modelo de eventos relativamente simples e a imensa quantidade de recursos online facilitam o aprendizado para novos desenvolvedores.

Criando um novo projeto no Visual Studio

Começar com um aplicativo Windows Forms é simples com o Visual Studio. Comece abrindo o Visual Studio e selecionando "Criar um novo projeto" na janela inicial. Na caixa de diálogo "Criar um novo projeto", use a barra de pesquisa para digitar "Aplicativo Windows Forms"—isso trará rapidamente o modelo que você precisa. Para restringir suas opções, filtre por C# como a linguagem e Windows como a plataforma.

Uma vez que você encontrar o tipo de projeto "Aplicativo Windows Forms (.NET Framework)", selecione-o e clique em Avançar. Na janela "Configurar seu novo projeto", dê um nome ao seu projeto (por exemplo, HelloWorld), escolha um local e então clique em Criar. O Visual Studio gerará uma nova solução e abrirá seu formulário principal, que serve como a interface gráfica do usuário para seu aplicativo. Este formulário é onde você irá projetar sua interface do usuário e adicionar controles, estabelecendo a fundação para seu aplicativo de desktop Windows. O modelo inclui todos os arquivos necessários e referências ao .NET Framework, assim você pode se concentrar em construir os recursos e funcionalidades do seu aplicativo imediatamente.

Analisando a Lógica do Botão Criar Torneio

Tim começa com uma revisão. Ele explica que tudo começa no botão Criar Torneio no programa. Em um programa C# WinForms, manipuladores de eventos são escritos para executar código em resposta a ações específicas do usuário, como clicar no botão Criar Torneio. Até este ponto, o aplicativo já:

• Validou a entrada do usuário

• Construiu o objeto do torneio

• Criou rodadas e confrontos na memória

A peça que falta, Tim explica, é persistir esses dados. Anteriormente, o aplicativo podia salvar torneios, prêmios e entradas—mas a informação das rodadas estava faltando. É isso que esta lição corrige.

Salvando o Torneio em SQL: A Visão Geral

Tim navega até o método CreateTournament do conector SQL e lembra aos espectadores que salvar dados segue um padrão claro:

1. Salvar o torneio em si

2. Obter o ID do torneio

3. Salvar prêmios

4. Salvar entradas

5. Agora: salvar rodadas e confrontos

Nota: É importante seguir esta ordem de salvamento para garantir que todos os dados relacionados estejam corretamente associados e a integridade dos dados do aplicativo seja mantida.

Tim enfatiza que padrões são bons, e esta lição segue o mesmo padrão estabelecido anteriormente.

WinForms também suporta a criação de elementos reutilizáveis de UI como botões, caixas de texto e rótulos, que ajudam a manter a consistência na estrutura dos dados do aplicativo.

Entendendo a Complexidade da Estrutura de Dados

Aqui, Tim faz uma pausa para explicar por que salvar rodadas é mais complexo.

• Um torneio tem Rodadas

• Cada rodada é uma lista de MatchupModel

• Cada confronto contém objetos MatchupEntryModel

Tim explica que isso é uma lista de uma lista, e que a complexidade é normal nesta etapa. Ele incentiva os espectadores a não entrarem em pânico—isso é apenas um resultado natural do modelamento de dados do mundo real.

Ele também observa que aplicativos WinForms são construídos usando componentes, como grades de dados e controles de UI, que ajudam os desenvolvedores a criar aplicativos de desktop ricos em recursos de forma eficiente. Todos os elementos visuais na biblioteca de classes do Windows Forms derivam da classe Control, fornecendo uma base consistente para construir e personalizar a interface do usuário.

Por que a Ordem de Salvamento Importa

Uma das explicações mais críticas do vídeo acontece aqui.

Tim explica que os dados devem ser salvos em ordem, porque:

• Uma entrada de confronto não pode ser salva até o ID do confronto pai existir

• Uma rodada não pode referenciar a próxima rodada até a anterior ter IDs

Ele explica que porque objetos referenciam os mesmos endereços de memória, uma vez que o ID é preenchido em um lugar, todas as referências são atualizadas automaticamente. No entanto, desenvolvedores podem precisar modificar referências de objeto à medida que IDs são atribuídos, que é uma parte típica do processo event-driven em aplicativos C# WinForms onde o aplicativo responde a ações do usuário e a mudanças de dados.

Assegurando que Todos os Modelos Tenham IDs

Tim aponta uma correção importante: MatchupEntryModel ainda não tem uma propriedade ID.

Mesmo se não for imediatamente necessário, Tim a adiciona mesmo assim, explicando que todo modelo com suporte a banco de dados deve ter um ID por consistência e uso futuro. Por padrão, aplicativos Windows Forms usam arquivos como Form1.Designer.cs para gerar automaticamente código de UI, assegurando uma estrutura e comportamento padrão na aplicação.

Dividindo a Lógica em Passos Simples

Esta seção serve como um tutorial para salvar dados em um aplicativo C WinForms.

Tim usa uma de suas analogias de ensino favoritas: comer um elefante uma mordida de cada vez.

Ele divide a lógica de salvamento em passos claros:

1. Passar por cada rodada

2. Dentro de cada rodada, passar por confrontos

3. Salvar cada confronto

4. Passar por entradas de confronto

5. Salvar cada entrada

Cada passo é simples por si só—e juntos, são poderosos.

O designer visual de arrastar e soltar simples no Visual Studio torna o WinForms excelente para construir ferramentas internas, protótipos e aplicativos simples.

Passando por Rodadas e Confrontos

Tim mostra como passar por uma lista de rodadas, onde cada rodada em si é uma lista de MatchupModel.

Ele intencionalmente evita var no início e explica por quê: tipos explícitos ajudam desenvolvedores a entender o que estão percorrendo, especialmente quando trabalham com listas aninhadas. Código claro é especialmente importante ao trabalhar com diferentes linguagens de programação no desenvolvimento de Windows Forms, pois melhora a manutenção e suporta a localização para vários idiomas.

Ele também compartilha uma filosofia importante:

"O melhor código é o que um desenvolvedor júnior consegue entender."

Aplicativos Windows Forms são event-driven e suportados pelo .NET Framework da Microsoft.

Criando o Procedimento Armazenado de Inserção de Confrontos

Tim muda para o SQL e cria spMatchups_Insert.

Ele explica os campos claramente:

• ID do Torneio

• Rodada de Confronto

• ID do Vencedor (nulo)

Campos adicionais, como data, podem ser incluídos para rastrear quando confrontos ocorrem.

Tim deliberadamente não define um vencedor nesta etapa. Mesmo se um confronto for um bye, ele prefere lidar com vencedores mais tarde usando a mesma lógica de confrontos reais.

Windows Forms proporciona acesso a Controles Comuns da Interface do Usuário nativos do Windows ao envolver a API do Windows existente em código gerenciado.

Salvando Entradas de Confronto e Lidando com NULLs

Tim cria outro procedimento armazenado: spMatchupEntries_Insert.

Ele explica:

• Pontuações são NULL porque jogos ainda não foram jogados

• NULL não é o mesmo que zero

• TeamCompeting pode ser NULL em rodadas posteriores

Ele dá um exemplo memorável usando futebol e golfe para explicar por que zero é um valor real, enquanto NULL significa que ainda não existe valor.

Configurações de aplicação podem ser configuradas no seu projeto Windows Forms para lidar com diferentes cenários de dados, como como valores NULL são exibidos ou processados em controles.

Windows Forms é incluído como parte do Microsoft .NET, .NET Framework, ou Mono.

Recursos e Funcionalidade de um Aplicativo .NET Framework

Um aplicativo Windows Forms construído sobre o .NET Framework oferece um conjunto poderoso de recursos para criar aplicativos de desktop modernos para Windows. Com Windows Forms (WinForms), você tem acesso a uma rica biblioteca de interface gráfica do usuário (GUI) que facilita o design de interfaces de usuário intuitivas e interativas. WinForms é um framework gratuito, open-source incluído com o Microsoft .NET, .NET Framework, e Mono, proporcionando integração perfeita com controles nativos do Windows e a API do Windows através de código gerenciado.

O IDE do Visual Studio aprimora sua experiência de desenvolvimento com ferramentas como o Designer de Windows Forms, que permite arrastar e soltar controles comuns—como botões, caixas de texto e rótulos—diretamente no seu formulário. Esta abordagem visual agiliza o design de UI e permite que você personalize propriedades e eventos usando a janela de Propriedades. Com suporte embutido para edição de código, depuração e gerenciamento de projetos, o Visual Studio simplifica o processo de construção, teste e refinamento de seus aplicativos para desktop Windows. Seja você criando ferramentas de negócios, utilitários ou software educacional, o .NET Framework e o WinForms oferecem uma plataforma robusta para entregar aplicativos ricos em recursos, responsivos e fáceis de usar.

Depurando com Editar e Continuar

Quando uma exceção ocorre, Tim não entra em pânico—ele ensina.

Ele usa o recurso Editar e Continuar do Visual Studio para:

• Pausar a execução

• Inserir verificações de nulos

• Retomar a execução sem reiniciar o aplicativo

Atalhos de teclado, como usar combinações 'Ctrl' (por exemplo, 'Ctrl + Alt + X' para abrir a Caixa de Ferramentas), podem acelerar a depuração e o acesso a controles de UI no Visual Studio.

Ele mostra como:

• Verificar se TeamCompeting é nulo

• Passar nulo para SQL em vez de acessar .ID

• Aplicar a mesma lógica para ParentMatchup

Este é um fluxo de trabalho de depuração do mundo real, exatamente como Tim o usa.

O Visual Studio oferece uma ampla gama de recursos e ferramentas para desenvolvimento em C#, incluindo o Designer de Windows Forms.

Verificando os Dados em SQL

Após corrigir dois pequenos bugs, Tim consulta o banco de dados.

Ele confirma:

• Confrontos são salvos corretamente

• Números das rodadas são precisos

• A lógica de bye funciona

• Relacionamentos pai-filho estão corretos

Observe os relacionamentos e dados corretos no banco de dados após salvar, pois este feedback visual é importante para verificar se a lógica do aplicativo está funcionando como pretendido.

Tim aponta que apenas dois erros ocorreram em um recurso muito complexo—e credita esse sucesso ao planejamento, padrões, e dividir o trabalho em pequenas partes.

Windows Forms fornece uma plataforma para escrever aplicativos clientes para desktop, laptop e PCs tablet, tornando-o uma escolha versátil para desenvolvimento em Windows.

Compilando e Preparando Métodos de Pesquisa

Tim começa assegurando que o projeto ainda compila antes de enfrentar partes inacabadas. Às 1:17:08, ele explica que o sistema passará strings em métodos e receberá um ou mais objetos MatchupEntryModel em retorno, retirados de arquivos de texto.

Às 1:17:40, Tim implementa um método chamado LookupTeamById(int id). Ele explica que quando dados são armazenados em um arquivo de texto, apenas o ID é salvo, não o objeto completo. Portanto, ao carregar dados, a aplicação deve "reidratar" aquele ID de volta em um TeamModel completo.

Tim aponta que essa não é uma lógica nova—ele simplesmente reutiliza o mesmo padrão já usado para carregar todos os times do arquivo. Ele enfatiza que essa reutilização é intencional e um benefício central de estruturar o código adequadamente. Os desenvolvedores também podem consultar métodos existentes e documentação oficial para orientação adicional ao implementar lógica semelhante.

Windows Forms é visto como um substituto para a anterior e mais complexa Biblioteca de Classes de Fundamentos da Microsoft baseada em C++ para desenvolvimento de GUI.

Centralizando Caminhos de Arquivo com GlobalConfig

À 1:20:27, Tim faz uma pausa e destaca um problema de design: nomes de arquivo estão sendo passados para todos os lugares, mesmo sendo constantes. Ele abertamente diz que isso parece "ridículo".

Para consertar isso, Tim move as constantes de nomes de arquivo para GlobalConfig, tornando-as públicas. À 1:21:33, ele explica que isso evita a passagem de caminhos de arquivos através de múltiplas camadas de métodos. O Solution Explorer no Visual Studio ajuda a gerenciar esses arquivos de projeto e a estrutura geral, tornando mais fácil localizar e atualizar tais constantes.

No entanto, às 1:22:24, Tim é honesto sobre uma falha: essas constantes agora existem em dois lugares—GlobalConfig e TextConnector. Ele explicitamente chama isso de violação do DRY (Don't Repeat Yourself) e nota que isso deve ser refatorado mais tarde, mas hoje não é esse dia.

Também é importante notar que Windows Forms não fornece um framework de aplicação padrão como a Microsoft Foundation Class (MFC).

Convertendo Strings em Modelos de Entrada de Competição

À 1:24:37, Tim começa a implementar ConvertStringToMatchupEntryModel. Ele explica que as entradas de competição são armazenadas como IDs delimitados por pipes, então o primeiro passo é dividir a string no pipe|). Ao contrário de aplicativos web que usam uma página como container de IU primário para navegação e layout, WinForms usa formulários para organizar a interface do usuário.

À 1:25:17, ele faz um loop por cada ID, o procura no arquivo de entradas de competição e adiciona o modelo correspondente a uma lista de saída. O padrão permanece consistente:

carregar → converter → filtrar por ID → retornar modelo

Tim ressalta que a consistência torna a depuração possível mais tarde.

Aplicativos Windows Forms podem ser desenvolvidos usando linguagens de programação .NET como C# ou Visual Basic.

Criando a Extensão ConvertToMatchupEntryModels

À 1:27:56, Tim cria um método de extensão ConvertToMatchupEntryModels(List ). Para guiar o processo, ele copia um método de conversão existente (para PersonModel) e o usa puramente como referência de padrão.

À 1:30:28, Tim mapeia colunas explicitamente:

• Coluna 0 → ID

• Coluna 1 → ID do TeamCompeting

• Coluna 2 → Pontuação

• Coluna 3 → ID do ParentMatchup

Ele explica que o valor armazenado é apenas um ID, portanto, o objeto completo deve ser reconstruído usando métodos de busca. Alguns componentes e temas de IU no WinForms são inspirados pelo Microsoft Office, como o Office 2019 Colorido e o Office 2019 Preto, para proporcionar uma experiência de usuário familiar.

Fornecedores de terceiros, como a DevExpress, oferecem suites completas de componentes de IU para WinForms.

Tratando de Manter Seguras as Competições-Pais

À 1:38:49, Tim identifica um problema importante: competições-pais podem não existir (especialmente na primeira rodada). Chamar First() em um ID ausente quebraria o app.

Sua correção às 1:39:09 usa int.TryParse. Se a análise falhar, ParentMatchup é definido como nulo. Tim explica cuidadosamente que isso é exatamente o que deve acontecer para competições da primeira rodada. Novos recursos e correções são frequentemente incluídos em cada versão do WinForms ou de bibliotecas de terceiros, melhorando como tais cenários são tratados.

Ele reforça que falhas são aceitáveis apenas quando dados inválidos nunca deveriam existir, como um ID de time inválido.

A Assinatura do DevExpress WinForms inclui mais de 190 controles de IU e bibliotecas, proporcionando extensas opções para construir aplicativos robustos.

Salvando Competições e Entradas em Arquivos

À 1:44:00, Tim avança para salvar dados. Ele carrega todas as competições, determina o próximo ID disponível, o atribui, e depois passa a salvar as entradas das competições. Após salvar seus dados, você pode testar o aplicativo clicando no botão Iniciar ou pressionando F5 no Visual Studio para executar seu aplicativo WinForms.

À 1:46:44, Tim destaca o poder de métodos reutilizáveis—carregar e converter arquivos agora é "chato", o que ele diz ser uma coisa boa.

Ele salva as entradas das competições primeiro para que cada entrada receba um ID, então salva a própria competição, que armazena aqueles IDs de entrada como strings delimitadas por pipes.

Além disso, a Assinatura DevExpress WinForms inclui um conjunto de relatórios com um designer de relatórios para o usuário final, que pode melhorar seus aplicativos WinForms.

Gravando Entradas de Competições no Banco de Dados

À 1:49:43, Tim constrói a lógica de salvamento linha por linha. Ele cuidadosamente reverte o padrão de conversão anterior:

• ID

• ID do Time em Competição (ou string vazia)

• Pontuação

• ID da Competição-Pai (ou string vazia)

Após explicar a lógica de salvamento, é importante notar que o WinForms é suportado em várias plataformas .NET, garantindo compatibilidade e atualizações contínuas.

À 1:52:02, Tim explica por que strings vazias são essenciais: elas preservam a ordem das colunas sem quebrar a lógica de análise.

Além disso, os controles DevExpress WinForms suportam aceleração de hardware DirectX para desempenho melhorado.

Salvando Competições e Vencedores

À 1:55:02, Tim salva as próprias competições. Como competições podem ter várias entradas, ele converte listas de entrada em strings delimitadas por pipes usando um método auxiliar reutilizado. Os desenvolvedores podem usar a Caixa de Ferramentas no Visual Studio para adicionar controles como botões e etiquetas aos seus Windows Forms, facilitando a criação da interface do usuário.

À 1:58:30, ele aplica a mesma lógica de tratamento de nulos para o campo vencedor. Se ainda não existir um vencedor, uma string vazia é salva.

Windows Forms permite que desenvolvedores criem aplicativos para desktops, tablets e PCs.

Reidratando Rodadas Quando Carregando Torneios

À 2:02:03, Tim aborda o TODO final: carregar informações de rodadas. Ele explica que rodadas são armazenadas como listas de IDs de competição, divididas primeiro por pipes, depois por acentos circunflexos (^).

À 2:09:13, ele reconstrói a estrutura aninhada completa:

• IDs → Modelos de Competição

• Modelos de Competição → Listas de Rodada

• Listas de Rodada → Modelo de Torneio

Após explicar a reconstrução, Tim observa que, ao contrário de alguns outros frameworks, o WinForms usa uma abordagem diferente para organizar interfaces de usuário e dados, o que pode afetar como desenvolvedores gerenciam estruturas aninhadas.

Tim enfatiza que esse aninhamento explica por que o código parece complexo—e por que percorrê-lo manualmente é tão importante.

Além disso, vale mencionar que a Assinatura DevExpress WinForms inclui temas e skins personalizáveis para aplicativos WinForms.

Depurando Erros Reais

A partir de 2:11:22, Tim intencionalmente executa o app e depura:

• NullReferenceException

• String de entrada não no formato correto

• Sequência não contém elementos

Ao invés de esconder os erros, Tim mostra exatamente como rastreá-los, inspecionar valores, e raciocinar sobre a ordem de execução. WinForms foi lançado pela primeira vez há anos e evoluiu ao longo do tempo.

À 2:20:30, ele identifica um problema de salvamento circular: competições precisavam existir antes que entradas pudessem referenciá-las. Sua solução é pragmática—salvar duas vezes. Ele abertamente admite que não é elegante, mas diz:

"Código funcionando é melhor que código refatorado que ainda tem um bug."

Windows Forms agora está disponível como um projeto de código aberto for .NET Core no GitHub.

Implantando um Aplicativo Windows Forms

Depois de construir e testar seu app Windows Forms no Visual Studio, o próximo passo é a implantação—tornar seu aplicativo disponível para os usuários. Visual Studio oferece várias opções de implantação, sendo ClickOnce uma das mais convenientes para aplicativos de desktop Windows. ClickOnce permite que você publique seu app em um compartilhamento de arquivos de rede, servidor web, ou até mesmo um CD/DVD, tornando a instalação fácil para os usuários finais.

Para implantar, basta usar as ferramentas de publicação do Visual Studio para empacotar seu app. Antes de publicar, teste minuciosamente seu aplicativo usando as ferramentas de depuração do Visual Studio para capturar e corrigir erros ou problemas em seu código. Uma vez implantado, os usuários podem instalar seu app executando o arquivo de configuração ou clicando em um atalho, e o app será executado, exibindo sua interface gráfica para interação imediata. Seja você escolher ClickOnce, Instalador do Windows, ou uma ferramenta de implantação de terceiros, o processo garante que seus usuários possam acessar toda a funcionalidade e recursos de seu app Windows Forms com o mínimo de complicações. Este processo de implantação simplificado ajuda você a entregar aplicativos desktop Windows confiáveis e profissionais para o seu público.

Considerações Finais

Ao final desta lição, Tim Corey demonstra um sistema completo e funcional de persistência de dados usando arquivos de texto como um banco de dados. Mais importante, ele mostra como bugs do mundo real surgem, como padrões guiam correções, e por que entender a ordem de execução importa mais do que a perfeição.

Esta lição não é sobre bancos de dados sofisticados—é sobre pensar como um desenvolvedor.