Migração de aplicações .NET legadas com GitHub Copilot
O upgrade com GitHub Copilot transforma a migração de uma aplicação ASP.NET MVC no .NET Framework 4.8 para o .NET 10 em um fluxo guiado, dividido em avaliação, planejamento e execução. Neste artigo, você acompanha esse processo completo dentro do Visual Studio, com o recurso GitHub Copilot App Modernization.
Durante muitos anos trabalhando com o ecossistema .NET, aprendi a respeitar profundamente a estabilidade do framework. Afinal, aplicações construídas sobre o .NET Framework 4.8, como projetos ASP.NET MVC 5, continuam funcionando de forma confiável e segura em muitos cenários corporativos.
Não há, por si só, nada de errado em manter esse tipo de aplicação em produção. No entanto, o desafio real surge quando a evolução tecnológica cria uma distância grande entre o que roda em produção e o que a plataforma oferece hoje em performance, segurança e produtividade.
Nesse contexto, a modernização de aplicações legadas, e o upgrade com GitHub Copilot em particular, deixa de ser apenas uma escolha técnica. Ela passa a ser uma decisão estratégica.
Por que modernizar aplicações .NET legadas
O .NET Framework 4.8 continua recebendo correções de segurança, porque faz parte do ciclo de vida do Windows. Por outro lado, ele não recebe novos recursos, novas APIs nem as melhorias de desempenho que chegam a cada versão do .NET moderno.
Enquanto isso, o .NET 10 é uma versão LTS, com suporte de longo prazo. Isso significa acesso a um runtime multiplataforma, a um pipeline HTTP mais enxuto e a um ecossistema de pacotes que evolui em ritmo acelerado.
Além disso, a distância entre as duas plataformas aumenta com o tempo. Quanto mais você adia a migração, mais pacotes NuGet ficam presos em versões antigas e mais APIs do System.Web se espalham pelo código.
Um exemplo recente mostra como o legado envelhece: o .NET Framework 3.5 deixará de vir nativo no Windows. Portanto, planejar a saída do framework antigo é uma forma de reduzir riscos antes que eles virem urgência.
O que muda entre ASP.NET MVC 5 e ASP.NET Core
A migração de ASP.NET MVC para ASP.NET Core não se resume a trocar o número da versão no projeto. Segundo o guia oficial de migração do ASP.NET Framework para o ASP.NET Core, as dependências de System.Web e o uso de HttpContext espalhado pelo código estão entre os maiores obstáculos.
Na prática, o arquivo Global.asax dá lugar ao Program.cs, e o web.config deixa de concentrar a configuração da aplicação. Em seu lugar, o ASP.NET Core usa o appsettings.json, variáveis de ambiente e o contêiner de injeção de dependência nativo.
Os arquivos estáticos também mudam de lugar, já que passam a morar na pasta wwwroot. Da mesma forma, autenticação, sessão, cache e tratamento de erros seguem modelos diferentes nas duas plataformas.
É exatamente esse volume de detalhes que torna a migração manual cansativa. Por isso, o upgrade com GitHub Copilot ganha relevância nesse cenário.
O papel do GitHub Copilot no upgrade de aplicações
Ferramentas de desenvolvimento assistido por inteligência artificial evoluíram muito nos últimos anos. O GitHub Copilot, especialmente em seu modo agente, vai além da simples sugestão de código.
Ele atua como um copiloto real no processo de modernização. Ou seja, no upgrade com GitHub Copilot o agente auxilia na análise, no planejamento e na execução de upgrades complexos.
No Visual Studio, o recurso de App Modernization já está disponível "out of the box", sem a necessidade de instalar extensões adicionais. A documentação oficial cita o Visual Studio 2026 e o Visual Studio 2022 a partir da versão 17.14.16 como ambientes compatíveis.
Esse conjunto de ferramentas permite que agentes do Copilot avaliem a base de código em detalhes. Assim, eles identificam riscos e dependências obsoletas e, em seguida, definem um plano estruturado de migração.
Vale lembrar que a Microsoft marcou o antigo .NET Upgrade Assistant como descontinuado. Com isso, o agente de modernização do GitHub Copilot passou a ser o caminho recomendado para novas migrações.
Caminhos suportados pelo agente
De acordo com o FAQ oficial, o upgrade com GitHub Copilot aceita projetos do .NET Framework em qualquer versão com destino ao .NET 8 ou superior. Além disso, ele cobre projetos do .NET Core 1.x a 3.x e do .NET 5 em diante.
O agente trabalha com MVC, Razor Pages, Web API, Blazor, ASP.NET Web Forms, Windows Forms, WPF, bibliotecas de classes e projetos de teste. Também aceita projetos em C# e em Visual Basic.
Existem, porém, alguns pré-requisitos importantes. O agente exige um repositório Git local e conexão com a internet, porque depende da infraestrutura em nuvem do Copilot.
A boa notícia é que ele funciona com todos os planos do Copilot, incluindo o gratuito. Para quem já usa o Copilot no terminal, vale conhecer também o GitHub Copilot CLI com agentes, MCP e automação, que oferece o mesmo agente de upgrade pela linha de comando.
Como iniciar o upgrade com GitHub Copilot
O processo começa de forma explícita e controlada. Primeiro, você seleciona o projeto ou a solução no Solution Explorer e aciona a opção Modernize no menu de contexto.
Em seguida, o Visual Studio abre uma sessão do GitHub Copilot Chat já preparada para conduzir a modernização. Alternativamente, você também pode abrir o chat e digitar @Modernize para chamar o agente.
Nesse momento, o objetivo principal fica claro: atualizar o projeto para o .NET 10. Na conversa, uma frase simples em linguagem natural basta, como "Upgrade my solution to .NET 10".
O Copilot então valida a versão de destino e confirma as branches de origem e de destino. A partir daí, ele inicia automaticamente o fluxo de modernização.
Esse fluxo se divide em três fases bem definidas, chamadas Assessment, Planning e Execution. Antes de começar, ele também pergunta como você prefere trabalhar, se de forma automática ou guiada passo a passo.
Por fim, vale reforçar que todo o upgrade com GitHub Copilot roda em uma branch de trabalho. Dessa forma, o código da branch principal permanece intacto até que você revise e aprove o resultado.
Fase 1 do upgrade com GitHub Copilot: Assessment
A primeira etapa consiste na criação de um arquivo assessment.md. Nessa fase, o Copilot analisa profundamente a aplicação e levanta métricas e pontos críticos, como:
- Dependências NuGet desatualizadas ou depreciadas
- APIs incompatíveis com versões modernas do .NET
- Potenciais vulnerabilidades de segurança
- Volume de código impactado pela migração
- Complexidade geral do upgrade
O resultado é um relatório executivo claro e objetivo. No caso analisado, o projeto apresentou alto grau de complexidade, com centenas de APIs afetadas e dezenas de pacotes que precisariam de atualização.
Esse documento não apenas orienta o agente durante o upgrade com GitHub Copilot. Ele também fornece ao desenvolvedor uma visão realista do esforço envolvido antes de qualquer linha de código mudar.
Onde ficam os arquivos do upgrade
Um ponto importante é que o agente salva esse arquivo em .github/upgrades, dentro do próprio repositório. Assim, você pode versionar a análise junto com o código.
Na documentação atual, os arquivos ficam em uma subpasta com o identificador do cenário, como dotnet-version-upgrade. A estrutura fica parecida com esta:
.github/
upgrades/
dotnet-version-upgrade/
assessment.md
upgrade-options.md
plan.md
scenario-instructions.md
tasks.md
Isso permite pausar o processo e retomá-lo depois, mantendo todo o histórico de decisões e análises. Inclusive, quando a pasta já existe, o Copilot pergunta se você quer continuar de onde parou ou começar do zero.
Você também pode editar o assessment.md para acrescentar contexto do projeto. Por exemplo, vale registrar que determinado pacote não pode sair ou que um módulo será descontinuado em breve.
Fase 2: Planning (planejamento)
Com base na avaliação, o upgrade com GitHub Copilot avança e gera o arquivo de planejamento. No fluxo demonstrado, ele recebeu o nome planning.md, enquanto a documentação atual da Microsoft se refere a ele como plan.md.
Aqui, o foco deixa de ser o diagnóstico e passa a ser a estratégia de execução. O plano inclui:
- Estratégia de migração adotada (por exemplo, atualização atômica)
- Sequência de etapas técnicas
- Mitigação de riscos
- Tratamento de dependências críticas
- Considerações sobre testes e validações
Antes do plano, o agente também apresenta opções de estratégia para você confirmar. Entre elas estão a ordem do upgrade (de baixo para cima, de cima para baixo ou tudo de uma vez) e a decisão de modernizar tecnologias como o Entity Framework 6.
No upgrade com GitHub Copilot, esse planejamento não é estático. Como desenvolvedor, posso revisar, ajustar ou até remover etapas inteiras do plano antes de seguir adiante.
Essa flexibilidade é fundamental para alinhar o processo às restrições reais do projeto e do time. Contudo, a documentação faz um alerta importante sobre as dependências entre projetos.
Se o projeto A depende do projeto B e você remove o B do plano, o upgrade do A pode falhar. Portanto, edite o plano com cuidado e respeite a ordem de dependências da solução.
Fase 3: Execution (execução)
Após a aprovação do plano, o Copilot gera o arquivo tasks.md, que detalha cada tarefa necessária para a migração. O agente organiza as tarefas por categorias, como:
- Verificação de pré-requisitos
- Atualização de pacotes
- Ajustes em arquivos de configuração
- Refatorações necessárias
- Execução e validação de testes
No upgrade com GitHub Copilot, cada tarefa traz critérios de validação, como "a solução compila sem erros" ou "todos os testes passam". Assim, o próprio agente sabe quando pode avançar para o próximo passo.
A partir desse ponto, posso autorizar o agente a executar as tarefas automaticamente. Durante a execução, o Copilot solicita permissões para ações sensíveis, como criação ou remoção de arquivos e execução de comandos.
O processo pode ser acompanhado em tempo real ou deixado rodando de forma semiautônoma. Enquanto isso, o agente atualiza o tasks.md com o status de cada etapa.
O que muda no projeto durante o upgrade com GitHub Copilot
Uma das transformações mais visíveis acontece no arquivo de projeto. Um .csproj antigo do .NET Framework, extenso e cheio de referências, costuma dar lugar ao formato SDK-style, bem mais curto:
<Project Sdk="Microsoft.NET.Sdk.Web">
<PropertyGroup>
<!-- Antes: <TargetFrameworkVersion>v4.8</TargetFrameworkVersion> -->
<TargetFramework>net10.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
</PropertyGroup>
</Project>
Da mesma forma, a inicialização que vivia no Global.asax migra para o Program.cs. Um ponto de partida típico para uma aplicação MVC no .NET 10 fica assim:
var builder = WebApplication.CreateBuilder(args);
// Registra controllers e views, substituindo o RouteConfig do MVC 5
builder.Services.AddControllersWithViews();
var app = builder.Build();
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
// Rota padrão equivalente à do RouteConfig.cs
app.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run();
Esses exemplos ilustram o tipo de mudança que o upgrade com GitHub Copilot propõe. Ainda assim, o código exato depende do projeto, e cabe a você revisar cada alteração.
Commits e controle sobre as mudanças
O Copilot faz commits de acordo com a estratégia de Git que você escolheu no início: por tarefa, por grupo de tarefas ou ao final. Com isso, o histórico do upgrade com GitHub Copilot fica auditável.
Além disso, como cada tarefa vira um commit separado, você pode aceitar apenas parte das mudanças. Basta usar comandos padrão do Git:
# Lista os commits gerados durante o upgrade
git log --oneline
# Aplica apenas um commit específico em outra branch
git cherry-pick <commit-hash>
Esse controle é valioso em times que preferem revisar a migração em etapas, por meio de pull requests menores.
Ajustes finais e depuração após o upgrade com GitHub Copilot
Mesmo após uma execução bem-sucedida, é comum que erros de runtime apareçam na primeira execução da aplicação. Isso faz parte do processo.
O Copilot reconhece quando o projeto compila, mas não tem visibilidade total do comportamento em tempo de execução. Por isso, a compilação limpa não garante que tudo funcione como antes.
Nesse momento, utilizo o próprio Copilot para depuração iterativa. Copio a mensagem de erro, descrevo o cenário e deixo o agente propor correções.
Esse ciclo do upgrade com GitHub Copilot se repete até que a aplicação esteja funcional. Na prática, cada iteração costuma resolver um problema de configuração, de pacote ou de comportamento diferente entre as plataformas.
Ao final, o resultado é claro: uma aplicação originalmente construída em ASP.NET MVC sobre .NET Framework agora executa com sucesso no .NET 10. O banco de dados inicializa, as dependências estão atualizadas e o código foi modernizado.
Checklist de validação
A documentação oficial recomenda uma verificação final antes de considerar o trabalho concluído. Em resumo, vale seguir estes passos:
- Revise o status final de todas as tarefas no
tasks.md. - Corrija testes com falha e erros de compilação restantes.
- Confirme que os pacotes NuGet atualizados são compatíveis com a aplicação.
- Teste a aplicação de ponta a ponta, incluindo fluxos de autenticação e acesso a dados.
- Avalie os novos recursos disponíveis na versão de destino.
Depois disso, você pode seguir para modernizações opcionais, como injeção de dependência e configuração via appsettings.json. Recursos do .NET 10, como o NuGet package pruning, também ajudam a limpar referências que ficaram sobrando.
Limitações e boas práticas no upgrade com GitHub Copilot
Apesar do ganho de produtividade, o agente tem limitações que a própria Microsoft documenta. Primeiro, as sugestões não têm garantia de seguir as melhores práticas em todos os casos.
Segundo, as correções que você faz durante a sessão não ficam memorizadas para upgrades futuros. No entanto, as preferências e decisões ficam salvas no scenario-instructions.md, o que mantém o contexto entre sessões do mesmo upgrade.
Quanto à privacidade, o agente não armazena o código nem o usa para treinar o modelo. Segundo o FAQ, ele coleta apenas telemetria agregada sobre tipos de projeto, intenção de upgrade e duração.
Algumas boas práticas tornam o processo mais seguro:
- Garanta uma suíte de testes mínima antes de iniciar a migração.
- Trabalhe sempre em uma branch dedicada e revise cada commit.
- Escolha um bom modelo de código no Copilot, já que a qualidade das correções depende dele.
- Registre no assessment as restrições de negócio que o agente não tem como conhecer.
Em outras palavras, o desenvolvedor continua no comando. O agente acelera o trabalho, mas a responsabilidade pelas decisões finais segue com o time.
Considerações finais
A modernização de aplicações legadas sempre carregou a fama de processo custoso, demorado e arriscado. Com o suporte do GitHub Copilot App Modernization, esse cenário muda de forma significativa.
No upgrade com GitHub Copilot, o uso de agentes inteligentes reduz o esforço manual e acelera decisões técnicas. Além disso, oferece uma trilha clara e auditável de todo o processo, registrada em arquivos markdown dentro do repositório.
Embora o desenvolvedor continue responsável pelas decisões finais e validações, o ganho de produtividade é inegável. Assim, atualizar aplicações legadas para versões modernas do .NET deixa de ser um projeto intimidador.
Ele passa a ser uma iniciativa viável, incremental e estrategicamente segura. Para quem mantém aplicações em versões antigas do .NET, recomendo fortemente experimentar o upgrade com GitHub Copilot.
A combinação de estabilidade do ecossistema com ferramentas modernas de IA cria um novo patamar para a evolução de software corporativo. No vídeo abaixo, você acompanha todo esse fluxo na prática:
FAQ
O que é o GitHub Copilot App Modernization?
É um agente do GitHub Copilot que avalia, planeja e executa o upgrade de projetos .NET para versões mais novas. No Visual Studio, ele aparece na opção Modernize do Solution Explorer.
Preciso instalar alguma extensão no Visual Studio?
Não, porque o recurso já vem integrado ao Visual Studio 2026 e ao Visual Studio 2022 a partir da versão 17.14.16. Basta estar conectado com uma conta do GitHub que tenha acesso ao Copilot.
Quais versões posso atualizar com o agente?
Projetos do .NET Framework em qualquer versão podem ir para o .NET 8 ou superior. Projetos do .NET Core 1.x a 3.x e do .NET 5 em diante também são suportados.
O upgrade funciona no plano gratuito do Copilot?
Sim, o agente funciona com todos os planos do Copilot, incluindo o gratuito. Ele exige, porém, conexão com a internet e um repositório Git local.
Posso pausar o processo e continuar depois?
Sim, porque os arquivos de assessment, plano e tarefas ficam em .github/upgrades no repositório. Ao reabrir a sessão, o Copilot retoma do ponto em que parou.
O código compilou, mas a aplicação falha ao rodar. E agora?
Isso é comum, já que o agente não enxerga todo o comportamento em tempo de execução. Copie o erro para o chat, descreva o cenário e itere com o Copilot até a aplicação funcionar.