Partilhar via

Crie o perfil do seu aplicativo com o GitHub Copilot Profiler Agent

O GitHub Copilot Profiler Agent trabalha em conjunto com o GitHub Copilot e orienta você através de testes e melhorias de desempenho.

Este tutorial demonstra como criar perfis de aplicativos e melhorar o desempenho usando o Copilot Profiler Agent.

O Profiler Agent pode executar todas as tarefas a seguir.

  • Analise o uso da CPU, as alocações de memória e o comportamento do tempo de execução.
  • Gargalos superficiais de desempenho.
  • Gere benchmarks BenchmarkDotNet ou otimize benchmarks BenchmarkDotNet existentes.
  • Aplique otimizações sugeridas.
  • Valide melhorias em um loop guiado.

O Profiler Agent é especialmente útil quando:

  • Você não está familiarizado com a criação de perfis.
  • Você não sabe por onde começar com o ajuste de desempenho.
  • Você deseja validar otimizações com benchmarks reais.
  • Está a trabalhar em aplicações de elevado desempenho, como jogos, serviços ou ferramentas de cliente.

Para obter informações sobre outros recursos de criação de perfil no Copilot, consulte Cenários aprimorados por IA. Para obter informações gerais sobre agentes Copilot e modo agente, consulte Usar modo de agente Copilot.

Pré-requisitos

Para começar, você precisa:

Iniciar uma sessão de criação de perfil

  1. No Visual Studio, crie um novo aplicativo de console C#.

    Na janela Iniciar, escolha Criar um novo projeto. Digite console na caixa de pesquisa, selecione C# como idioma e escolha Aplicativo de Console para .NET. Escolha Próximo. Digite um nome de projeto como ConsoleApp_CopilotProfile e selecione Avançar. Escolha uma estrutura de destino (por exemplo, .NET 8) e escolha Criar.

  2. No Gerenciador de Soluções, clique com o botão direito do mouse no nó Dependências no projeto, escolha Gerenciar pacotes NuGet, procure EntityFramework e adicione os seguintes pacotes ao projeto:

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

    O aplicativo usa um banco de dados na memória para simplificar a configuração do projeto.

  3. Substitua o código no Program.cs pelo seguinte código:

    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. Selecione Build > Build Solution para garantir que o aplicativo seja compilado sem erros.

Peça informações sobre o perfil ao Copilot

  1. Abra a janela Copilot Chat e use o seguinte prompt.

    @Profiler Please evaluate the performance of this code

  2. Selecione Enviar.

    O @Profiler comando chama o Copilot Profiler Agent.

    Captura de tela mostrando a invocação do agente do profiler.

    Como alternativa, você pode iniciar o agente do profiler escolhendo manualmente Select Tools e habilitando manualmente o Profiler Agent e, em seguida, alternando para o modo de agente. Usando esse método, você não precisa usar o @Profiler comando.

    O copiloto pergunta se você deseja executar o criador de perfil.

    Captura de ecrã do pedido de criação de perfil inicial.

  3. Escolha Confirmar.

    O agente executa uma série de etapas de forma independente. Ele examina o código, adiciona suporte ao projeto para BenchmarkDotNet, incluindo referências de projeto e pacotes, adiciona benchmarks a um novo arquivo e executa teste de comparação com o novo código que ele gera.

    Os resultados do benchmark aparecem na janela Saída, com a saída definida como Hub de Diagnóstico.

    Captura de tela da saída de benchmark.

    Os resultados da sessão de diagnóstico aparecem em um relatório de arquivo .diagsession . Se você quiser investigar manualmente o uso da CPU, consulte Analisar o desempenho usando a criação de perfil da CPU. No entanto, nesse cenário, usamos o Profiler Agent em vez disso.

    Quando termina o teste, o agente resume suas descobertas.

    O agente relata um potencial ganho de eficiência de 33%, principalmente pela remoção da materialização da mesa cheia e uma chamada de método desnecessária ToList() .

    Captura de ecrã dos resultados dos testes.

    O agente também fornece algumas sugestões para as próximas etapas, incluindo uma opção para otimizar a consulta LINQ.

    Captura de ecrã de sugestões de código.

    Neste exemplo, você se concentra em otimizar a consulta LINQ.

  4. Selecione a segunda sugestão do Copilot e selecione Enviar para dizer ao agente para otimizar a cadeia de consultas LINQ.

    O agente atualiza Program.cs e fornece sugestões adicionais para otimizar o código. Vamos pular essas sugestões por enquanto.

  5. Dê uma olhada nas alterações de código no Program.cs.

    Captura de ecrã das alterações de código.

  6. No canto inferior direito do editor de código, examine as alterações de código e selecione Manter para mantê-las.

    A consulta otimizada é mostrada aqui.

     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. Se você quiser que o agente faça otimizações adicionais, selecione as sugestões fornecidas pelo agente ou faça perguntas adicionais.

Continue o bate-papo depois de atingir o limite de token

O Profiler Agent fornece resumo inteligente juntamente com a continuação da conversa de chat, projetado para manter o seu trabalho fluindo sem ser bloqueado por atingir limites de tokens.

Se um bate-papo com o Copilot se aproximar de seu limite de token, você será solicitado com a opção de resumir e continuar em um novo tópico.

Captura de tela do resumo do tópico.

Se você selecionar essa opção, o agente gerará automaticamente um resumo conciso e rico em contexto do thread de bate-papo atual e o levará adiante para uma nova conversa. Isso permite que você evite refazer quaisquer etapas.

  • Last updated on