GitHub Copilot moderniseringskoncept

GitHub Copilot modernisering använder en strukturerad metod för att uppgradera .NET projekt. Genom att förstå hur agenten fungerar, inklusive scenarier, färdigheter, uppgifter och arbetsflöden, kan du samarbeta effektivt med agenten och få bästa möjliga resultat.

Agenten som lagkamrat

Agenten utmärker sig i samarbete, inte automatisering i ett vakuum:

• Deep .NET knowledge: Agenten förstår projektfiler, NuGet-beroenden, brytande ändringar och uppgraderingsmönster i dussintals .NET-tekniker för både C#- och Visual Basic-projekt.
• Strukturerat arbetsflöde: Varje uppgradering går igenom utvärdering, planering och körning. Inga slumpmässiga ändringar, inga överraskningar.
• Lär dig dina inställningar: När du säger "använd alltid explicita typer i stället för var" skriver agenten den inställningen till scenario-instructions.md och kommer ihåg den över sessioner.
• Kan korrigeras mitt under flygning: Ringde du fel? Berätta för agenten. Den anpassar och tillämpar korrigeringen framöver.
• Förklarar dess resonemang: Fråga "varför valde du den metoden?" och agenten vägleder dig genom beslutet.

Scenarier

Ett scenario är ett hanterat arbetsflöde för modernisering från slutpunkt till slutpunkt. När du säger till agenten att "uppgradera min lösning till .NET 10" utlöser du scenariot .NET version upgrade.

Så här identifieras scenarier

Du behöver inte memorera scenarionamn. Agenten identifierar relevanta scenarier automatiskt:

1. Analyserar din kodbas för att förstå vilka tekniker du använder, inklusive språk, ramverksversion, bibliotek och projekttyper.
2. Identifierar vilka scenarier som är relevanta för dina projekt.
3. Rangordna scenarier efter prioritet och vikt. De mest relevanta framträder först.

Du kan också fråga direkt: "Vilka scenarier är tillgängliga för min lösning?"

Scenariobeständighet

Varje aktivt scenario får en egen mapp på .github/upgrades/{scenarioId}/. Scenariomappen innehåller planen, aktivitetsstatusen, dina inställningar och körningsloggarna. Mappen är en del av din Git-lagringsplats.

En fullständig lista över scenarier finns i Scenarier och kunskapsreferens.

Arbetsflödets livscykel

Varje scenario följer samma livscykel: ett arbetsflöde i tre steg.

Steg 1: Utvärdering

Agenten samlar in allt den behöver innan den börjar arbeta:

• Målramverk: Den version som du uppgraderar till.
• Git-strategi: Agenten föreslår branchning och du styr detaljerna: ett grennamn, om du vill använda en gren per uppgift och den tidpunkt för commit.
• Flödesläge: Automatisk (agentstyrd) eller Guidat (du godkänner varje steg).
• Scenariospecifika parametrar: Beroende på scenariot kan agenten ställa fler frågor.

Agenten initierar scenarioarbetsytan på .github/upgrades/{scenarioId}/.

Agenten analyserar sedan din kodbas:

• Projektets beroendediagram (topologisk ordning)
• NuGet-paketkompatibilitet med målramverket
• Icke-bakåtkompatibla API-ändringar
• Testtäckning
• Komplexitet och riskfaktorer

Agenten sparar en omfattande utvärderingsrapport till assessment.md.

Baserat på utvärderingen utvärderar agenten din lösning och identifierar vilka uppgraderingsbeslut som är relevanta. Den presenterar lämpliga standardvärden och låter dig granska och åsidosätta val.

Alternativen kan vara:

• Uppgraderingsstrategi: Nedifrån och upp, uppifrån och ned eller allt på en gång.
• Projektuppgraderingsmetod: Omskrivning på plats eller parallellt utförande för webbapplikationer; på plats eller flermålssikting för bibliotek.
• Teknikmodernisering: Alternativ för Entity Framework-uppgradering, beroendeinmatning, loggning och konfiguration.
• Pakethantering: Om och när du ska implementera central pakethantering.
• Kompatibilitetshantering: Så här hanterar du API:er och paket som inte stöds.

Agenten sparar bekräftade beslut till upgrade-options.md.

I guidat läge pausar agenten här för din granskning innan du fortsätter.

Steg 2: Planering

Agenten skapar uppgiftsplanen baserat på utvärderingen och dina bekräftade alternativ. Planering skapar tre nyckelfiler:

• plan.md: Uppgraderingsplanen med strategi- och uppgiftsbeskrivningar.
• scenario-instructions.md: Dina inställningar, beslut och agentens minne.
• tasks.md — Den ordnade listan över uppgifter som agenten ska utföra.

Steg 3: Utförande

Agenten arbetar genom uppgifter sekventiellt. För varje uppgift i tasks.mdföljer agenten en cykel: starta, köra, validera (skapa och testa) och slutföra. Du styr när och hur agenten genomför ändringar: per aktivitet, per grupp med uppgifter eller i slutet. När agenten arbetar uppdaterar den tasks.md med livestatusindikatorer så att du kan spåra förloppet.

Uppgraderingsstrategier

Under utvärderingsfasen utvärderar agenten din lösning och rekommenderar en av följande strategier:

Färdigheter

Färdigheter är mindre, målinriktade moderniseringsmöjligheter. När agenten stöter på EF6-kod under en uppgradering läser den in EF6-till-EF-Core-färdigheten med detaljerade och stegvisa uppgraderingsinstruktioner. Anropa en färdighet direkt under en uppgradering: "uppgradera WCF-tjänsterna i mitt projekt till CoreWCF."

Agenten levereras med över 30 inbyggda kunskaper ordnade efter domän:

• Dataåtkomst: EF6 till EF Core (code-first och EDMX), LINQ till SQL och SqlClient-uppgradering
• Web/ASP.NET: Identity, Global.asax, OWIN, MVC routing/filters/bundling och WCF till CoreWCF
• Serialization: Newtonsoft.Json till System.Text.Json
• Cloud: Azure Functions in-process till isolerad arbetsmodell
• Bibliotek: ADAL till MSAL, SignalR, PowerShell SDK, och med mera

Färdigheter läses in automatiskt baserat på vad agenten läser av i din kodbas. Du behöver inte hantera laddning av färdigheter. Beskriv bara vad du behöver.

Den fullständiga listan finns i Scenarier och kunskapsreferens.

Tasks

Uppgifter är atomiska arbetsenheter i ett scenario. Varje uppgift representerar en specifik, begränsad del av uppgraderingen, till exempel "Uppgradera CommonLib från .NET 6 till .NET 10" eller "Uppgradera EF6-användning i DataLayer till EF Core".

Aktivitetslivscykel

Uppgifter går genom följande tillstånd:

• Tillgänglig: Redo att starta, alla beroenden är uppfyllda.
• Pågår: Agenten arbetar aktivt med uppgiften.
• Slutfört: Kodändringar är tillämpade, bygget godkänns, tester är godkända.

För varje uppgift, agenten:

1. Läser in relaterade färdigheter och kontext.
2. Utvärderar komplexiteten och avgör om uppgiften behöver underaktiviteter.
3. Skriver en omfångssammanfattning till tasks/{taskId}/task.md.
4. Kör kodändringar.
5. Validerar genom att köra bygge och tester.
6. Registrerar resultat i tasks/{taskId}/progress-details.md.
7. Genomför ändringar och flyttas till nästa uppgift.

Statushantering

Agenten har ett beständiga tillstånd så att du kan stoppa och återuppta när som helst. Allt finns på din lagringsplats under .github/upgrades/{scenarioId}/.

Återupptagande

Stäng chatten, stäng din IDE eller kom tillbaka nästa dag. Agenten fortsätter där den slutade:

1. Vid nästa interaktion kontrollerar agenten arbetsytans aktuella tillstånd automatiskt.
2. Agenten identifierar det befintliga scenariot och visar aktuellt förlopp, till exempel "3 av 8 slutförda uppgifter".
3. Agenten identifierar inaktuella uppgifter (som har fastnat i en tidigare avbruten session) och erbjuder sig att återuppta eller starta om dem.
4. Agenten läser in dina inställningar igen från scenario-instructions.md.

Kontinuitet mellan IDE

Eftersom tillståndet finns i Git kan du växla mellan VS Code, Visual Studio och Copilot CLI mitt i uppgraderingen. Mappen .github/upgrades/ är det delade tillstånd som båda IDE:erna förstår.

Flödeslägen

Agenten stöder två flödeslägen som styr hur mycket tillsyn du har: automatiskt läge och guidat läge.

Automatiskt läge

Agenten arbetar igenom alla steg (utvärdering, planering och körning) utan att pausa för godkännande. Den visar viktiga resultat och förloppsuppdateringar, men fortsätter framåt.

Bäst för erfarna användare, enkla uppgraderingar och små lösningar.

Guidat läge

Agenten pausar vid varje steggräns för din granskning:

• Efter utvärderingen: "Här är vad jag hittade. Ska jag fortsätta med uppgraderingsalternativen?"
• Efter planeringen: "Här är uppgiftsplanen. Vill du att jag ska börja genomföra?"
• Innan komplexa aktivitetsuppdelningar: "Den här aktiviteten är komplex. Så här skulle jag bryta ner det."

Bäst för förstagångsanvändare, komplexa lösningar och när du vill lära dig processen.

Växla lägen när som helst

• Säg "pausa" eller "växla till guidat" för att växla till guidat läge.
• Säg "fortsätt" eller "fortsätt" för att växla till Automatiskt läge.

Relaterat innehåll

• Vad innebär modernisering av GitHub Copilot?
• Referens för scenarier och färdigheter
• Uppgradera en .NET app med GitHub Copilot modernisering
• Bästa praxis
• Felsöka GitHub Copilot-moderniseringen