Condividi tramite

Che cos'è la modernizzazione di GitHub Copilot?

GitHub Copilot la modernizzazione è un agente di GitHub Copilot che consente di aggiornare i progetti a versioni più recenti di .NET e migrare applicazioni .NET su Azure in modo rapido e sicuro. Illustra la valutazione, le raccomandazioni sulle soluzioni, le correzioni del codice e la convalida in Visual Studio, Visual Studio Code, interfaccia della riga di comando di GitHub Copilot e GitHub.com.

Usare questo agente per:

  • Eseguire l'aggiornamento a una versione più recente di .NET.
  • Eseguire la migrazione delle tecnologie e della distribuzione in Azure.
  • Modernizzare l'app .NET, in particolare durante l'aggiornamento da .NET Framework.
  • Valutare il codice, la configurazione e le dipendenze dell'applicazione.
  • Pianificare e configurare la risorsa Azure corretta.
  • Risolvere i problemi e applicare le procedure consigliate per la migrazione cloud.
  • Verificare che l'app venga compilata e verificata correttamente.

Scenari

L'agente fornisce più flussi di lavoro di modernizzazione end-to-end denominati scenari. Ogni scenario è un flusso di lavoro gestito che guida l'utente attraverso un tipo specifico di aggiornamento o migrazione:

Scenario Descrizione Richiesta di esempio
Aggiornamento della versione di .NET Aggiornamenti da versioni .NET precedenti a .NET 8, 9, 10 o versioni successive. "Aggiornare la soluzione a .NET 10"
Conversione in stile SDK Converte il formato di progetto legacy in stile SDK. "Converti in stile SDK"
Migrazione di Newtonsoft.Json Sostituisce Newtonsoft.Json con System.Text.Json. "Eseguire la migrazione da Newtonsoft.Json"
Migrazione di SqlClient Esegue la migrazione da System.Data.SqlClient a Microsoft. Data.SqlClient. "Update SqlClient"
aggiornamento Funzioni di Azure Aggiorna Funzioni di Azure dal modello di lavoro "in-process" a quello "isolato". "Aggiorna le Funzioni di Azure"
Kernel semantico per gli agenti Esegue la migrazione degli agenti di Kernel semantico all'intelligenza artificiale degli agenti Microsoft. "Eseguire la migrazione degli agenti SK"

Per un riferimento completo a tutti gli scenari e a 30 competenze di migrazione predefinite, vedere Scenari e informazioni di riferimento sulle competenze.

Inviare commenti

Microsoft valori il feedback e lo usa per migliorare l'agente. Lasciare commenti e suggerimenti usando una di queste opzioni:

Prerequisiti

Configurare GitHub Copilot modernizzazione nell'ambiente di sviluppo prima di usare l'agente. Per i passaggi di installazione, vedere Installazione della modernizzazione di GitHub Copilot.

Aggiornare i progetti di .NET

L'agente di modernizzazione supporta l'aggiornamento di progetti C# e Visual Basic dei tipi seguenti:

  • ASP.NET Core (e tecnologie correlate, ad esempio MVC, Razor Pages e API Web)
  • Blazor
  • Funzioni di Azure
  • Windows Presentation Foundation (macchine virtuali Windows)
  • Windows Forms
  • WinUI
  • .NET MAUI e Xamarin
  • Librerie di classi
  • Applicazioni console
  • Progetti di test (MSTest, NUnit e xUnit)

Per avviare un aggiornamento, vedere Aggiornare un'app .NET tramite modernizzazione con GitHub Copilot.

Percorsi di aggiornamento supportati

L'agente supporta i percorsi di aggiornamento seguenti:

origine Destinazione
.NET Framework (qualsiasi versione) .NET 8 o versioni successive
.NET Core 1.x–3.x .NET 8 o versioni successive
.NET 5 o versioni successive .NET 8 o versioni successive

Eseguire la migrazione di progetti .NET a Azure

L'agente di modernizzazione semplifica Azure migrazioni tramite l'analisi automatizzata, la correzione del codice basata su intelligenza artificiale, i controlli di compilazione e vulnerabilità e l'automazione della distribuzione:

  • Analisi e raccomandazioni intelligenti.

    Valuta l'idoneità della tua applicazione per la migrazione ad Azure e ricevi indicazioni personalizzate in base alle sue dipendenze e ai problemi identificati.

  • Correzione del codice basata su intelligenza artificiale.

    Applicare modelli di codice di procedura consigliata predefiniti per accelerare la modernizzazione con un lavoro manuale minimo.

  • Compilazione automatica e risoluzione CVE.

    Compilare l'app e risolvere gli errori di compilazione e le vulnerabilità, semplificando lo sviluppo.

  • Distribuzione senza interruzioni.

    Eseguire la distribuzione in Azure, portando il codice dallo sviluppo alla produzione più velocemente.

Attività predefinite per la migrazione

La modernizzazione con GitHub Copilot per .NET offre attività predefinite che acquisiscano le procedure consigliate del settore e riguardano scenari di migrazione comuni.

  • Migrare a Database basati su identità gestita su Azure, inclusi Azure SQL DB, Azure SQL MI e Azure PostgreSQL

    Modernizzare il livello dati eseguendo la migrazione da database locali o legacy (ad esempio DB2, Oracle DB o SQL Server) a database Azure SQL, Istanza gestita di SQL di Azure o Azure PostgreSQL. Usare l'autenticazione tramite identità gestita sicura.

  • Migrare ad Archiviazione file di Azure

    Spostare le operazioni di I/O dei file dal file system locale ad Azure File Storage per una gestione dei file scalabile basata sul cloud.

  • Migra su Archiviazione BLOB di Azure

    Sostituire l'archiviazione di oggetti in sede, l'archiviazione di oggetti tra cloud o l'I/O dei file del file system locale con Archiviazione BLOB di Azure per i dati non strutturati.

  • Migrate a Microsoft Entra ID

    Eseguire la transizione dell'autenticazione e dell'autorizzazione da Windows Active Directory a Microsoft Entra ID (in precedenza Azure AD) per la gestione moderna delle identità.

  • Migrare verso credenziali protette usando Managed Identity e Azure Key Vault

    Sostituire le credenziali in testo non crittografato nella configurazione o nel codice con identità sicure, gestite e Azure Key Vault per la gestione dei segreti.

  • Migrare ad bus di servizio di Azure

    Passare da code di messaggi legacy o di terze parti (ad esempio MSMQ o RabbitMQ) o Amazon SQS (AWS Simple Queue Service) a bus di servizio di Azure per la messaggistica affidabile basata sul cloud.

  • Migrate per Azure messaggio di posta elettronica del servizio di comunicazione

    Sostituire l'invio diretto della posta elettronica SMTP con Azure Servizio di comunicazione per il recapito di posta elettronica scalabile e sicuro.

  • Migrare a Confluent Cloud/Azure Event Hub per Apache Kafka

    Transizione da Kafka locale o locale allo streaming di eventi gestiti con Confluent Cloud o Hub eventi di Azure.

  • Migrare a OpenTelemetry su Azure

    Eseguire la transizione da framework di registrazione locali, ad esempio log4net, Serilog e registro eventi di Windows a OpenTelemetry su Azure.

  • Migra a cache di Azure per Redis usando l'identità gestita

    Sostituire le implementazioni della cache Redis in memoria o locale con cache di Azure per Redis per la disponibilità elevata, la scalabilità e la sicurezza di livello aziendale.

Come funziona

Per avviare un processo di aggiornamento o migrazione, vedere:

  1. Aprire il progetto o la soluzione .NET nell'ambiente di sviluppo.

  2. Avviare l'agente usando uno di questi metodi:

    • Visual Studio: fare clic con il pulsante destro del mouse sulla soluzione o sul progetto in Esplora soluzioni e selezionare Modernize. In alternativa, aprire la finestra GitHub Copilot Chat e digitare @Modernize.
    • Visual Studio Code: aprire il pannello GitHub Copilot Chat e digitare @modernize-dotnet.
    • GitHub Copilot cli: digitare @modernize-dotnet seguito dalla richiesta di aggiornamento o migrazione.
    • GitHub.com: usare l'agente di codifica modernize-dotnet nel repository.

  3. Indicare all'agente cosa aggiornare o eseguire la migrazione.

Quando si chiede all'agente di modernizzazione di aggiornare l'app, Copilot prima chiede di creare un nuovo ramo se si lavora in un repository Git. Quindi Copilot valuta il progetto ed esegue un flusso di lavoro in tre fasi. Ogni fase produce file Markdown sotto .github/upgrades/{scenarioId} nel tuo repository, così puoi esaminare ciò che viene dopo prima di continuare. Se .github/upgrades/{scenarioId} esiste già da un tentativo precedente, Copilot chiede se continuare o iniziare da capo.

Copilot inizia esaminando la struttura del progetto, le dipendenze e i modelli di codice per creare una valutazione completa. Il assessment.md file elenca le modifiche di rilievo, i problemi di compatibilità delle API, i modelli deprecati e l'ambito di aggiornamento.

Dopo la valutazione, Copilot esegue le tre fasi seguenti:

  1. Assessment: Copilot esamina la struttura del progetto, le dipendenze e i modelli di codice, quindi presenta decisioni di strategia per la revisione, ad esempio la strategia di aggiornamento (dal basso verso il basso, dall'alto verso il basso o all-in-once), l'approccio alla migrazione del progetto, le opzioni di modernizzazione della tecnologia e la gestione della compatibilità. Copilot salva le decisioni confermate in upgrade-options.md.

  2. Planning: Copilot converte la valutazione e le opzioni confermate in una specifica dettagliata. Il plan.md file documenta strategie di aggiornamento, approcci di refactoring, percorsi di dipendenza e mitigazioni dei rischi.

  3. Execution: Copilot suddivide il piano in attività sequenziali concrete con criteri di convalida in tasks.md. Ogni attività descrive una singola modifica e come Copilot conferma l'esito positivo.

Modificare uno dei file Markdown in .github/upgrades/{scenarioId} per modificare i passaggi di aggiornamento o aggiungere contesto prima di procedere.

Strategie di aggiornamento

Durante la fase di valutazione, l'agente valuta la soluzione e consiglia una di queste strategie:

Strategia Ideale per Descrizione
Dal basso verso l'alto Soluzioni di grandi dimensioni con grafici di dipendenza profondi Aggiorna prima i progetti foglia, quindi procede verso l'alto.
Dall'alto verso il basso Feedback rapido sull'applicazione principale Aggiorna prima il progetto dell'applicazione, quindi corregge le dipendenze.
All-at-once Soluzioni piccole e semplici Aggiorna tutti i progetti in un unico passaggio.

Modalità di flusso

L'agente supporta due modalità di flusso che regolano quanto si ferma per il tuo input.

  • Automatico: L'agente funziona in tutte le fasi senza interruzioni, fermandosi solo davanti a blocchi effettivi. Ideale per utenti esperti e aggiornamenti semplici.
  • Guidato: L'agente si ferma a ciascun confine di fase in modo da poter esaminare la valutazione, il piano e le attività prima di procedere. Ideale per gli utenti che lo usano per la prima volta e per soluzioni complesse.

Passare da una modalità all'altra in qualsiasi momento pronunciando "pausa" (per entrare in modalità guidata) o "continua" (per entrare in modalità automatica).

Gestione dello stato

L'agente archivia tutti gli stati di aggiornamento in .github/upgrades/{scenarioId}/. La cartella contiene:

File Scopo
assessment.md Analisi della soluzione
upgrade-options.md Decisioni di aggiornamento confermate
plan.md Piano attività ordinato
tasks.md Dashboard dei progressi in tempo reale
scenario-instructions.md Memoria persistente dell'agente, incluse preferenze, decisioni e istruzioni personalizzate
execution-log.md Tracciamento dettagliato di tutte le modifiche
tasks/{taskId}/task.md Ambito e contesto di attività singola
tasks/{taskId}/progress-details.md Note e risultati dell'esecuzione per singola attività

Poiché tutti gli stati si trovano in questa cartella, è possibile chiudere l'IDE, passare da una sessione all'altra o anche passare da un ambiente di sviluppo all'altro( ad esempio, iniziare in VS Code e continuare in Visual Studio). L'agente riprende da dove si era interrotto.

Suggerimento

Effettua il commit della cartella .github/upgrades/ nel tuo ramo. Lo stato confermato funge da backup e consente ai membri del team di visualizzare il progresso dell'aggiornamento.

Eseguire l'aggiornamento.

Al termine di ogni fase, esaminare e modificare i file generati in base alle esigenze e quindi indicare Copilot di continuare con la fase successiva.

Quando si raggiunge la fase Execution, indicare Copilot di avviare l'aggiornamento. Se Copilot si verifica un problema, tenta di identificare la causa e di applicare una correzione. Se Copilot non riesce a risolvere il problema, chiede aiuto. Quando si interviene, Copilot apprende dalle modifiche apportate e tenta di applicarle automaticamente se il problema si ripresenta.

Risultati dell'aggiornamento

Quando Copilot esegue ogni attività, aggiorna il file tasks.md in .github/upgrades/{scenarioId} con lo stato di ogni passaggio. Monitorare lo stato di avanzamento esaminando questo file. Copilot crea un commit Git per ogni parte del processo, in modo da poter eseguire il rollback delle modifiche o esaminare le modifiche apportate.

Al termine dell'aggiornamento, Copilot visualizza i passaggi successivi nella risposta della chat.

Telemetria

Lo strumento raccoglie i dati sui tipi di progetto, sulla finalità di aggiornare e sulla durata dell'aggiornamento. L'ambiente di sviluppo raccoglie e aggrega i dati e non contiene informazioni identificabili dall'utente. Per altre informazioni sull'informativa sulla privacy di Microsoft, vedere Visual Studio Customer Experience Improvement Program.

Contenuti correlati

  • Last updated on