Modificação de dados em tempo real na tela - Série Spectre Console

Introdução à Exibição ao Vivo

Tim começa explicando o Spectre.Console e como ele torna seus aplicativos de console visualmente atraentes. Nesta série, cada lição é um exemplo curto, e o código-fonte está disponível no link na descrição.

Ele explica que esta lição se concentra em como usar o recurso de exibição ao vivo para modificar os dados existentes na tela para atualizações em tempo real. Tim também incentiva os espectadores a se inscreverem e visitarem o site iamtimcorey.com para obterem mais recursos de treinamento.

Criando uma nova tabela para dados

Tim mostra que já criou uma nova tabela com as colunas título, aulas e horas. Esta tabela será usada para exibir informações do curso obtidas por meio de uma API.

Ele também introduz um tipo de registro chamado CourseInfo com propriedades fortemente tipadas para nome do curso, número de aulas e duração do curso em horas. Isso espelha a estrutura da API e permite que ele gere texto facilmente de forma fortemente tipada.

A tabela tem a opção de exibir rodapés ativada para que os totais possam ser mostrados posteriormente. Tim observa que esse layout é um dos muitos widgets arbitrários que o Spectre suporta para aplicativos de console visualmente atraentes.

Iniciando a exibição ao vivo

Tim usa o método AnsiConsole.Live(table).StartAsync(...) para iniciar a exibição ao vivo. Ele destaca que também existe uma função Start() não assíncrona, caso você não precise aguardar tarefas de longa duração.

Ele envolve seu código em um contexto assíncrono para que o console possa ser atualizado à medida que novas linhas chegam. Isso demonstra a capacidade do terminal atual de redesenhar a saída sem limpar a tela.

Obtendo dados e exibindo o progresso

No contexto em tempo real, Tim escreve um loop for usando um índice inteiro de 1 a 31 porque a API de exemplo lista 31 cursos. Para cada índice, ele chama um método de classe auxiliar para buscar dados da API.

Esta função auxiliar converte a string JSON bruta em um objeto CourseInfo fortemente tipado. Tim chama intencionalmente a API um curso de cada vez, em vez de em lote, para mostrar como o progresso da exibição acontece ao vivo — um ótimo exemplo de simulação de tarefas de longa duração em um ambiente de console.

Ele observa que, se quisesse apenas uma solicitação, poderia ter removido o /i da URL, mas está fazendo várias chamadas "para mostrar as informações que chegam ao longo do tempo".

Adicionando linhas e atualizando a saída

A cada instância de CourseInfo retornada, Tim chama table.AddRow(...) para criar uma nova linha com o título do curso, a contagem de lições e a duração em horas. Ele usa interpolação de strings com o formato $ e chama .ToString() quando necessário para converter valores que não são strings.

Isso renderiza a tabela com novas linhas a cada passagem, mostrando como o Spectre pode atualizar linhas dinamicamente. Ele também demonstra como identificar possíveis problemas, como incompatibilidades de tipos, sendo explícito sobre as conversões.

Rodapés personalizados e totais acumulados

Em seguida, Tim mostra como adicionar rodapés personalizados às colunas. Ele define table.Columns[0].Footer para mostrar a contagem de cursos baixados até o momento. Ele repete esse processo para a segunda e terceira colunas, mas desta vez soma a quantidade de aulas e o total de horas em todos os cursos.

Dessa forma, o usuário pode ver rapidamente quantas lições e quantas horas acumulou. Este é um exemplo prático de como usar os controles do Spectre para exibir totais de valores junto com dados em tempo real.

Tim "desafixou" brevemente a janela para que você possa ver o layout completo à medida que os números aumentam. Ele explica que os rodapés fazem parte dos estilos integrados que o Spectre oferece, assim como bordas, marcação e temas.

Atualizando o contexto após cada ação

Tim enfatiza o "ponto crucial" sobre as telas em tempo real: sempre chame context.Refresh() após fazer alterações. Isso garante que o terminal realmente redesenhe sua saída com os novos dados. Sem isso, suas linhas, rodapés ou mesmo cores diferentes não apareceriam até o final da sessão ao vivo.

Depuração e tratamento de exceções

Ao executar o código pela primeira vez, Tim se depara com uma exceção de índice fora do intervalo. Ele explica seu erro — contar incorretamente os índices das colunas (eles são 0,1,2 e não 0,2,3) — e o corrige.

Este é um lembrete amigável de que, mesmo no Spectre.Console, você deve capturar erros e garantir que seus índices e argumentos estejam corretos.

Assistindo à demonstração ao vivo em ação.

Tim executa o código corrigido e mostra a exibição ao vivo em ação: linhas sendo adicionadas, totais sendo atualizados e o rodapé exibindo os valores combinados.

Você pode ver "1.652 aulas", "403,5 horas" e "31 cursos no total" conforme os dados são recebidos. É exatamente esse tipo de ação que faz com que a exibição ao vivo do Spectre Console pareça um painel de controle dentro do seu terminal atual.

Focando apenas nos rodapés

Para tornar as alterações mais visíveis, Tim comenta o código que adiciona linhas, de forma que apenas os rodapés sejam atualizados. Isso demonstra como, mesmo sem rolar a tela, é possível acompanhar os totais em tempo real.

Ele também observa que o Spectre ajusta automaticamente a largura da coluna quando os números aumentam (por exemplo, de 9 para 10). Este é um exemplo pequeno, mas poderoso, da detecção automática de larguras e formatos pela biblioteca.

Além das Tabelas – Widgets e Temas Arbitrários

Tim explica que a exibição ao vivo não se limita às mesas. Você pode aplicá-lo a widgets diversos, como painéis, campos de entrada do usuário ou até mesmo um gráfico de barras. Você pode atualizar o texto, destacar cores diferentes, aplicar temas personalizados com código de cores ou adicionar indicadores de rotação.

Ele menciona que você pode alterar estilos como azul, verde ou cinza para combinar com seus temas, e que você pode até trabalhar com layouts aninhados ou widgets. Essa flexibilidade é o que torna o Spectre "fortemente inspirado" por ferramentas de console avançadas em outros ecossistemas (algumas até escritas em Python), mas adaptadas para o .NET.

Início da exibição ao vivo assíncrona vs. síncrona

Tim esclarece por que usou a versão assíncrona: porque estava aguardando chamadas de API. Se suas atualizações não forem assíncronas, você pode simplesmente chamar Start() sem await.

Essa opção ajuda você a criar aplicativos de console atraentes que permanecem responsivos mesmo durante tarefas de longa duração.

Conclusão

Em seu vídeo , Tim mostrou como construir uma exibição ao vivo do Spectre Console que pode atualizar, somar e atualizar dados diretamente no console.

Esta é uma ótima base para solicitar a entrada de dados do usuário, adicionar widgets ou criar painéis com cores diferentes e temas personalizados com códigos de cores. Combinando isso com a capacidade do Spectre de gerar texto facilmente, usar marcação e criar controles como painéis ou árvores, você pode criar aplicativos .NET dinâmicos diretamente no seu terminal.

A demonstração de Tim mostra que com o Spectre.Console você pode criar não apenas painéis, mas também tabelas, indicadores de rotação e outros widgets com atualização em tempo real. É um exemplo prático de como transformar um console simples em uma ferramenta interativa em tempo real — e uma ótima maneira de desejar "boa programação" aos seus usuários.