Profilera din app med GitHub Copilot

I den här artikeln får du lära dig hur du profilerar program och förbättrar prestandan med Hjälp av Copilot och Copilot Profiler Agent.

Copilot kan hjälpa dig genom att rekommendera profileringsverktyg som matchar din kod och genom att analysera specifika problem som identifieras med profileringsverktyg.

Profiler-agenten, som vägleder dig genom prestandatestning och förbättring, fungerar tillsammans med GitHub Copilot för att:

• Analysera CPU-användning, minnesallokeringar och körningsbeteende.
• Flaskhalsar för ytprestanda.
• Generera BenchmarkDotNet Benchmarks eller optimera befintliga BenchmarkDotNet-riktmärken.
• Tillämpa föreslagna optimeringar.
• Verifiera förbättringar i en guidad loop.

Profiler-agenten är särskilt användbar när:

• Du är inte bekant med profilering.
• Du är osäker på var du ska börja med prestandajustering.
• Du vill validera optimeringar med verkliga riktmärken.
• Du arbetar med högpresterande appar som spel, tjänster eller klientverktyg.

Allmän information om Copilot-agenter och agentläge finns i Använda Copilot-agentläge.

Förutsättningar

För att komma igång behöver du:

• Visual Studio version 18.0.0 Förhandsversion 1 eller senare
• Logga in i Visual Studio med ett GitHub-konto med Copilot-åtkomst
  ^** Du kan använda GitHub Copilot kostnadsfritt. Registrera dig och utnyttja AI för att koda snabbare och effektivare.

AI-förbättrade scenarier

Copilot förstår din kod och Visual Studio-profileringsverktygen. Därför kan du interagera med profilerarmedveten AI för att ställa detaljerade frågor som rör din kod och prestandaproblem i allmänhet.

Copilot ger mer exakt hjälp för vissa målscenarier, till exempel de som beskrivs i följande tabell.

I vissa av dessa scenarier får du riktad hjälp med hjälp av knappen Fråga Copilot Eller knappen Analysera med Copilot . Copilot känner redan till kontexten för dina frågor. Den känner till exempel till insikter som identifieras av profileringsverktygen och kan ge relevanta förslag på hur de kan åtgärdas.

Profil med copilotprofileringsagenten

I följande exempel visas hur du samlar in prestandadata med Copilot Profiler-agenten och sedan använder den för att analysera resultaten och för att föreslå och göra korrigeringar.

Starta en profileringssession

1. Skapa en ny C#-konsolapp i Visual Studio.

   I startfönstret väljer du Skapa ett nytt projekt. Skriv konsolen i sökrutan, välj C# som språk och välj sedan Konsolapp för .NET. Välj Nästa. Skriv ett projektnamn som ConsoleApp_CopilotProfile och välj Nästa. Välj ett målramverk (till exempel .NET 8) och välj Skapa.

2. Högerklicka på noden Beroenden i projektet i Solution Explorer, välj Hantera NuGet-paket, sök efter EntityFramework och lägg sedan till följande paket i projektet:

   • Microsoft.EntityFramework.Core
   • Microsoft.EntityFramework.Core.InMemory

   Appen använder en minnesintern databas för att förenkla projektkonfigurationen.

3. Ersätt koden i Program.cs med följande kod:

   using System.Diagnostics;
   using Microsoft.EntityFrameworkCore;
   
   // Configure EF Core to use the InMemory provider
   var options = new DbContextOptionsBuilder<AppDbContext>()
       .UseInMemoryDatabase("PerfDemoDb")
       .Options;
   
   using var db = new AppDbContext(options);
   
   // Seed 100,000 records once
   if (!db.People.Any())
   {
       var rand = new Random(42);
       var cities = new[]
       {
           "Chicago", "Seattle", "Cairo", "London", "Paris",
           "Cleveland", "Calgary", "Dallas", "Berlin", "Copenhagen"
       };
   
       var people = Enumerable.Range(1, 100_000).Select(i => new Person
       {
           Name = $"Person {i}",
           Age = rand.Next(18, 80),
           City = cities[rand.Next(cities.Length)]
       });
   
       db.People.AddRange(people);
       db.SaveChanges();
   }
   
   Console.WriteLine($"Seeded records: {db.People.Count():N0}");
   
   // Inefficient LINQ pattern: materialize everything and repeatedly re-materialize + chain ToList
   // This simulates client-heavy work that doesn't scale, even with in-memory provider
   var sw = Stopwatch.StartNew();
   
   // Full materialization of all rows
   var all = db.People.ToList();
   
   // Extra ToList calls create multiple large intermediate lists
   var inefficient = all
       .Where(p => p.Age > 50)
       .ToList()
       .Where(p => p.City.StartsWith("C"))
       .ToList()
       .Select(p => p.Name)
       .Distinct()
       .OrderBy(n => n)
       .Take(10)
       .ToList();
   
   sw.Stop();
   Console.WriteLine($"Inefficient query returned {inefficient.Count} rows in {sw.ElapsedMilliseconds} ms");
   
   // EF Core entity
   public class Person
   {
       public int Id { get; set; }
       public string Name { get; set; } = string.Empty;
       public int Age { get; set; }
       public string City { get; set; } = string.Empty;
   }
   
   // EF Core DbContext
   public class AppDbContext : DbContext
   {
       public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }
       public DbSet<Person> People => Set<Person>();
   }
   

4. Välj Skapa > bygglösning för att se till att appen byggs utan fel.

Be Copilot om profileringsinsikter

1. Öppna Copilot Chat-fönstret och använd följande prompt.

   @Profiler Please evaluate the performance of this code

2. Välj Skicka.

   Kommandot @Profiler anropar Copilot Profiler Agent.

   

   Du kan också starta profileraragenten genom att manuellt välja Välj verktyg och manuellt aktivera Profiler-agenten och sedan växla till agentläge. Med den här metoden behöver du inte använda @Profiler kommandot .

   Copilot frågar om du vill köra profileraren.

   

3. Välj Bekräfta.

   Agenten går igenom en serie steg oberoende av varandra. Den undersöker koden, lägger till stöd för projektet för BenchmarkDotNet, inklusive projektreferenser och paket, lägger till benchmarks i en ny fil och kör jämförelsetest mot ny kod som genereras.

   Benchmark-resultat visas i utdatafönstret med utdata inställda på Diagnostikhubb.

   

   Resultat från diagnostiksessionen visas i en .diagsession-filrapport . Om du vill undersöka CPU-användning manuellt kan du läsa Analysera prestanda med hjälp av CPU-profilering. I det här scenariot använder vi dock Profiler-agenten i stället.

   När testningen är klar sammanfattar agenten sina resultat.

   Agenten rapporterar en potentiell 33-% öka effektiviteten, främst genom att ta bort fullständig tabellmaterialisering och ett onödigt ToList() metodanrop.

   

   Agenten innehåller också ett par förslag för nästa steg, inklusive ett alternativ för att optimera LINQ-frågan.

   

   I det här exemplet fokuserar du på att optimera LINQ-frågan.

4. Välj det andra Copilot-förslaget och välj Skicka för att be agenten att optimera LINQ-frågekedjan.

   Agenten uppdateras Program.cs och innehåller ytterligare förslag för att optimera kod. Vi hoppar över dessa förslag för tillfället.

5. Ta en titt på kodändringar i Program.cs.

   

6. Längst ned till höger i kodredigeraren granskar du kodändringarna och väljer Behåll för att behålla dem.

   Den optimerade frågan visas här.

    var optimized = db.People
        .AsNoTracking()
        .Where(p => p.Age > 50 && p.City.StartsWith("C"))
        .Select(p => p.Name)
        .Distinct()
        .OrderBy(n => n)
        .Take(10)
        .ToList();
   

7. Om du vill att agenten ska göra ytterligare optimeringar väljer du antingen de förslag som tillhandahålls av agenten eller ställer ytterligare frågor.

Fortsätt chatta när du har nått tokengränsen

Profileragenten tillhandahåller smart sammanfattning tillsammans med fortsättning av chatttrådar, utformade för att hålla ditt arbete flytande utan att blockeras av att nå tokengränser.

Om en chatt med Copilot närmar sig sin tokengräns uppmanas du att sammanfatta och fortsätta i en ny tråd.

Om du väljer det här alternativet genererar agenten automatiskt en kortfattad, kontextrik sammanfattning av den aktuella chatttråden och för den vidare till en ny konversation. På så sätt kan du undvika att gå tillbaka till några steg.