Compartilhar via

Criar o perfil do aplicativo com o GitHub Copilot Profiler Agent

O GitHub Copilot Profiler Agent funciona junto com o GitHub Copilot e orienta você por meio de testes de desempenho e melhoria.

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

O Agente de Profiling pode executar todas as tarefas a seguir.

  • Analise o uso da CPU, as alocações de memória e o comportamento do runtime.
  • Gargalos de desempenho de superfície.
  • Gere BenchmarkDotNet Benchmarks ou otimize os parâmetros de comparação do BenchmarkDotNet existentes.
  • Aplicar otimizações sugeridas.
  • Validar melhorias em um loop guiado.

O Agente do Criador de Perfil é especialmente útil quando:

  • Você não está familiarizado com a criação de perfil.
  • Você não tem certeza de por onde começar com o ajuste de desempenho.
  • Você deseja validar otimizações com parâmetros de comparação reais.
  • Você está trabalhando em aplicativos de alto 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 de IA. Para obter informações gerais sobre os agentes copilot e o modo de agente, consulte Usar o modo de agente copilot.

Pré-requisitos

Para começar, você precisa do seguinte:

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

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

    Na janela inicial, escolha Criar um novo projeto. Digite o console na caixa de pesquisa, selecione C# como o idioma e escolha o Aplicativo de Console para .NET. Escolha Próxima. 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, pesquise 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 em 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 Compilar > solução de build para garantir que o aplicativo seja compilado sem erros.

Pergunte ao Copilot para obter insights de criação de perfil

  1. Abra a janela de Chat do Copilot e use o prompt a seguir.

    @Profiler Please evaluate the performance of this code

  2. Selecione Enviar.

    O @Profiler comando chama o Copilot Profiler Agent.

    Captura de tela da invocação do agente do criador de perfil.

    Como alternativa, você pode iniciar o agente do criador de perfil escolhendo manualmente Selecionar Ferramentas e habilitando manualmente o Agente do Criador de Perfil e alternando para o modo de agente. Usando esse método, você não precisa usar o @Profiler comando.

    Copilot pergunta se você deseja executar o criador de perfil.

    Captura de tela da solicitação iniciar a criação de perfil.

  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 parâmetros de comparação a um novo arquivo e executa um teste de comparação em relação ao novo código gerado.

    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 do parâmetro de comparação.

    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 Agente do Criador de Perfil.

    Quando terminar o teste, o agente resume suas descobertas.

    O agente relata um potencial de 33% ganho de eficiência, principalmente removendo a materialização de tabela completa e uma chamada de método desnecessária ToList() .

    Captura de tela dos resultados do teste.

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

    Captura de tela das sugestões de código.

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

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

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

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

    Captura de tela 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.

Continuar o chat depois de atingir o limite do token

O Agente do Criador de Perfil fornece resumo inteligente junto com a continuação do thread de chat, projetada para manter seu trabalho fluindo sem ser bloqueado atingindo os limites de token.

Se um chat com o Copilot se aproximar de seu limite de token, você será solicitado com a opção de resumir e continuar em um novo thread.

Captura de tela do resumo do thread.

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

  • Last updated on