Aggiornare un'app macchine virtuali Windows a .NET con modernizzazione GitHub Copilot

Questo articolo illustra come aggiornare un'app desktop macchine virtuali Windows a .NET usando l'agente di modernizzazione GitHub Copilot. L'agente funziona nel tuo editor, analizza il progetto e guida un flusso di lavoro in tre fasi: valutazione, pianificazione ed esecuzione.

L'esempio usa l'esempio Matching Game, una piccola applicazione macchine virtuali Windows .NET Framework composta da un progetto principale e una libreria di classi.

Prerequisiti

• Windows sistema operativo.
• Visual Studio 2026.
• Scaricare ed estrarre l'app demo usata con questo articolo.
• L'SDK .NET per la versione di destinazione. Questo articolo riguarda .NET 10.
• Repository Git per la soluzione. L'agente esegue il commit dello stato di avanzamento, quindi il progetto deve essere sotto il controllo del codice sorgente.
• Modernizzazione con GitHub Copilot disponibile per Visual Studio. Per altre informazioni, vedere Installare la modernizzazione di GitHub Copilot.

Aprire la soluzione

I progetti Matching Game sono destinati a .NET Framework 4.5. Visual Studio chiede di impostare nuovamente i progetti in una versione supportata di .NET Framework quando si apre la soluzione.

1. Aprire la soluzione MatchingGame in Visual Studio.
2. Visual Studio visualizza la finestra di dialogo Framework di destinazione non installato.
3. Selezionare Aggiorna la destinazione a .NET Framework 4.8 (scelta consigliata) e quindi selezionare Continua.
4. Aprire la finestra Modifiche Git ed eseguire il commit delle modifiche di reindirizzamento.

Note importanti per Visual Basic

L'agente di modernizzazione GitHub Copilot non supporta completamente i progetti Visual Basic .NET. L'agente include protezioni progettate specificamente per garantire che i progetti C# vengano aggiornati in modo affidabile e tali protezioni interferiscano con l'analisi e l'esecuzione del progetto VB. Se la soluzione contiene progetti VB, usare invece una di queste alternative:

• GitHub Copilot (agente standard): usare il normale agente Copilot, senza l'agente di modernizzazione, per guidare l'aggiornamento in modo interattivo.
• Installare .NET Upgrade Assistant: strumento di migrazione dedicato con supporto di VB.

Se si usa manualmente il agente Copilot standard o l'aggiornamento, seguire questa procedura:

1. Se il progetto è destinato a una versione non supportata di .NET Framework, reindirizzarlo prima a .NET Framework 4.8. Visual Studio chiede di eseguire questa operazione quando si apre la soluzione oppure è possibile modificarla nelle proprietà del progetto.

2. Aggiornare tutti i pacchetti NuGet obsoleti alle versioni compatibili più recenti.

3. Creare un nuovo progetto di macchine virtuali Windows VB usando un modello di Visual Studio o dotnet new wpf -lang vb. Il modello genera un file di progetto e impostazioni di tipo SDK, che sono state modificate da .NET Framework.

4. Copiare i .vb file di origine dalla cartella del progetto precedente alla nuova cartella del progetto.

5. Copiare eventuali file non di codice da cui dipende il progetto, ad esempio app.configfile .settings , immagini, icone e altre risorse incorporate.

6. Aprire il file di progetto precedente (o packages.config) e prendere nota di ogni riferimento al pacchetto NuGet. Aggiungere gli stessi pacchetti al nuovo progetto usando il Gestione pacchetti NuGet o dotnet add package <name>.

7. Se il progetto fa riferimento ad altri progetti nella soluzione, aggiungere nuovamente tali riferimenti nel nuovo progetto.

8. Provare a compilare la soluzione. Non correggere ancora gli errori — l'output della compilazione fornisce a Copilot un elenco concreto di problemi su cui lavorare.

9. Esegui il commit dello stato corrente nel sistema di controllo del codice sorgente, in modo da avere una baseline pulita prima che Copilot apporti modifiche.

10. Aprire GitHub Copilot Chat e chiedere di risolvere i problemi rimanenti. Per esempio:

    Questo progetto Visual Basic macchine virtuali Windows è stato migrato da .NET Framework 4.8 a .NET 10. Il file di progetto e i file di origine sono disponibili, ma la soluzione non viene compilata. Esaminare gli errori di compilazione e correggere le incompatibilità dell'API, i riferimenti mancanti e eventuali problemi di migrazione della configurazione.

11. Esaminate le modifiche proposte da Copilot, quindi ricompilate e testate il progetto.

Avviare l'aggiornamento

La soluzione Matching Game contiene l'app MatchingGame e la libreria di classi MatchingGame.Logic. L'agente individua autonomamente il grafo del progetto, quindi avvia l'aggiornamento a livello della soluzione.

1. In Esplora soluzioni fare clic con il pulsante destro del mouse sulla soluzione e scegliere Modernize (Modernize).

   Viene visualizzata la finestra di Copilot Chat GitHub e viene avviata una conversazione con l'agente di modernizzazione.

2. Selezionare un modello con solide funzionalità di ragionamento e codifica.

3. Dimmi all'agente cosa vuoi fare. Per esempio:

   Aggiornare tutto a .NET 10.

   L'agente segnala lo stato corrente della codebase e le operazioni da eseguire:

   • Framework di destinazione: indica che l'agente aggiorna i progetti a .NET 10.
   • Modalità flusso: l'impostazione predefinita è Automatica. Per le app complesse, chiedere all'agente di passare alla modalità guidata .
   • Controllo del codice sorgente: indica che l'agente crea un nuovo ramo di lavoro.

   L'agente scrive il proprio lavoro in .github/upgrades/scenarios/dotnet-version-upgrade/ nel repository. Se tale cartella esiste già da un tentativo precedente, l'agente chiede se continuare o avviare un nuovo tentativo.

4. Indicare all'agente start di avviare il processo di aggiornamento.

Esaminare la valutazione

Nella fase di valutazione, l'agente esamina la struttura del progetto, le dipendenze e i modelli di codice per identificare ciò che deve cambiare. Scrive i risultati in assessment.md in .github/upgrades/scenarios/dotnet-version-upgrade/.

Quando Copilot completa la valutazione, rivedi l'output della conversazione. In genere inizia con qualcosa di simile al seguente:

Assessment Complete

I've analyzed the solution and created a full assessment — see .github/upgrades/scenarios/dotnet-version-upgrade/assessment.md.

Solution: MatchingGame.slnx → target: net10.0

Compatibility Statistics:

- Projects: 2 (both currently on net48, legacy project format)
- Issues: 100 (Mandatory: 91, Potential: 9, Optional: 0)
- Affected Files: 6
- Affected Technologies: WPF (61 issues), Legacy Configuration System (2 issues)

Projects:

| Project                                      | Current TFM | Type                  |
|----------------------------------------------|-------------|-----------------------|
| MatchingGame.Logic\MatchingGame.Logic.csproj | net48       | Classic Class Library |
| MatchingGame\MatchingGame.csproj             | net48       | Classic WPF           |

Key issues found:

- Both projects use legacy (non-SDK-style) project format → must be converted to SDK-style
- Both project target frameworks need to change to net10.0
- WPF project (MatchingGame.csproj) has binary/source/behavioral API incompatibilities and Legacy Configuration System usage

No security vulnerabilities were detected, and no NuGet packages are referenced — this is a self-contained WPF + library solution.
Proceeding to planning now. You can ask me to pause and switch to Guided mode at any time.

Esaminare le opzioni di aggiornamento

Dopo la valutazione, l'agente presenta le decisioni sulla strategia di aggiornamento upgrade-options.md e le salva in .github/upgrades/scenarios/dotnet-version-upgrade/. Per l'esempio di gioco corrispondente, l'agente seleziona le opzioni seguenti:

L'agente segnala anche i rischi che richiedono la tua attenzione. Esaminare le opzioni proposte e indicare all'agente cosa si vuole modificare. Ad esempio, dire all'agente di abilitare i tipi di riferimento nullable o di modificare il modo in cui vengono gestiti i pacchetti incompatibili. Al termine, rispondere confirm per bloccare le selezioni e passare alla pianificazione.

Esaminare il piano

Nella fase di pianificazione, l'agente converte la valutazione e le opzioni confermate in una specifica dettagliata. Scrive il risultato in plan.md e crea un scenario-instructions.md file che archivia preferenze, decisioni e istruzioni personalizzate per l'aggiornamento.

Il piano include elementi come l'ordine di aggiornamento tra progetti, il moniker del framework di destinazione per ogni progetto (net10.0-windowsper i progetti macchine virtuali Windows), i percorsi di aggiornamento dei pacchetti e le mitigazioni dei rischi per le modifiche di rilievo rilevate dalla valutazione.

Per esaminare e personalizzare il piano:

1. Apri plan.md in .github/upgrades/scenarios/dotnet-version-upgrade/.
2. Esaminare le strategie di aggiornamento e gli aggiornamenti delle dipendenze.
3. Modificare il piano per modificare i passaggi o aggiungere contesto in base alle esigenze.
4. Indicare all'agente di passare alla fase di esecuzione.

Eseguire l'aggiornamento

Nella fase di esecuzione, l'agente suddivide il piano in attività sequenziali e concrete con criteri di convalida. L’agente scrive l’elenco di attività in .github/upgrades/scenarios/dotnet-version-upgrade/tasks.md e tiene traccia dell’avanzamento complessivo in quel file. Per ogni attività, l'agente crea una cartella in .github/upgrades/scenarios/dotnet-version-upgrade/tasks/ che contiene un file Markdown che descrive l'attività e un file markdown che segnala lo stato dell'attività.

Per l'esempio di gioco corrispondente, l'elenco di attività include in genere l'aggiornamento di MatchingGame.Logic , quindi MatchingGame, il ripristino di pacchetti, la compilazione della soluzione e il commit delle modifiche.

Per eseguire l'aggiornamento:

1. Indicare all'agente di avviare l'aggiornamento.
2. Monitora i progressi esaminando tasks.md man mano che l'agente aggiorna gli stati delle attività. Aprire le cartelle per attività in tasks/ per la descrizione dell'attività e un report di stato dettagliato.
3. Se l'agente si imbatte in un problema che non può risolvere, fornisci l'aiuto richiesto. Ad esempio, l'agente potrebbe chiedere di scegliere tra due API sostitutive o confermare se mantenere un pacchetto deprecato.
4. In base alle risposte, l'agente adatta la strategia alle attività rimanenti e continua.

L'agente esegue il commit delle modifiche in base alla strategia Git configurata durante la pre-inizializzazione: per attività, per gruppo di attività o alla fine.

Note per i progetti Visual Basic

I progetti macchine virtuali Windows di Visual Basic in .NET Framework usano spesso i file di impostazioni System.Configuration e le estensioni My, ad esempio My.Computer e My.User. Le My estensioni sono state rimosse in .NET. L'agente contrassegna questi modelli durante la valutazione e propone correzioni durante l'esecuzione, ma potrebbe essere necessario confermare le singole modifiche durante un'esecuzione guidata.

Se l'agente esegue la migrazione del progetto ma questo non si compila, verificare che il file di progetto sia destinato a Windows e faccia riferimento a macchine virtuali Windows. L'elemento <PropertyGroup> dovrebbe essere simile al frammento di codice seguente:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net10.0-windows</TargetFramework>
    <UseWPF>true</UseWPF>
    <OutputType>WinExe</OutputType>
    <MyType>Windows</MyType>

    <!-- Other settings removed for brevity. -->
  </PropertyGroup>
</Project>

Verificare l'aggiornamento

Al termine dell'aggiornamento, l'agente consiglia i passaggi successivi nella risposta alla chat. Richiedere all'agente di generare un report di modifica completo con "Generare un report di modifica".

Esaminare lo stato dell'attività finale in tasks.md e verificare che ogni passaggio sia stato completato.

Per verificare l'aggiornamento:

1. Compilare la soluzione e risolvere eventuali errori di compilazione.
2. Eseguire l'app e confermare che le finestre e le visualizzazioni caricano e si comportano come previsto. Esaminare eventuali differenze visive o comportamentali nei controlli XAML e nei controlli personalizzati tra .NET Framework e .NET.
3. Eseguire tutti gli unit test nella soluzione e correggere gli errori.
4. Verificare che i pacchetti NuGet aggiornati siano compatibili con l'app.
5. Testare attentamente l'app per verificare che l'aggiornamento sia stato completato.

L'esempio di gioco corrispondente macchine virtuali Windows viene ora aggiornato a .NET 10.

Esperienza post-aggiornamento

Se l'app è stata convertita da .NET Framework a .NET, vedere Modernizzare le app di .NET Framework aggiornate per idee sull'adozione di modelli più recenti, ad esempio appsettings.json configurazione, inserimento delle dipendenze o servizi cloud. L'adozione di questi modelli è separata dall'aggiornamento a .NET e non è necessario completare l'aggiornamento.

Contenuti correlati

• Panoramica dell'aggiornamento delle app macchine virtuali Windows
• Procedure consigliate per la modernizzazione GitHub Copilot
• Panoramica dell'aggiornamento delle app .NET
• Modernizzare le app .NET Framework aggiornate
• Le modifiche di rilievo possono influire sulla conversione dell'app