Compartir a través de

Perfila tu aplicación con el Agente de creación de perfiles de Copilot Profiler de GitHub

El agente de GitHub Copilot Profiler funciona junto con GitHub Copilot y le guía por las pruebas de rendimiento y la mejora.

En este tutorial se muestra cómo generar perfiles de aplicaciones y mejorar el rendimiento mediante el Agente de Copilot Profiler.

El Agente de Profiler puede realizar todas las tareas siguientes.

  • Analice el uso de CPU, las asignaciones de memoria y el comportamiento en tiempo de ejecución.
  • Cuellos de botella de rendimiento de la superficie.
  • Genere benchmarkDotNet Benchmarks o optimice las pruebas comparativas de BenchmarkDotNet existentes.
  • (ASP.NET) Analice los contadores de .NET.
  • Aplicar optimizaciones sugeridas.
  • Valide las mejoras en un bucle guiado.

El agente de Profiler es especialmente útil cuando:

  • No está familiarizado con la generación de perfiles.
  • No está seguro de dónde empezar con el ajuste del rendimiento.
  • Quiere validar las optimizaciones con pruebas comparativas reales.
  • Está trabajando en aplicaciones de alto rendimiento, como juegos, servicios o herramientas de cliente.

Para obtener información sobre otras características de generación de perfiles en Copilot, consulte Escenarios mejorados por ia. Para obtener información general sobre los agentes de Copilot y el modo de agente, consulte Uso del modo agente de Copilot.

Prerrequisitos

Para empezar, necesita lo siguiente:

Iniciar una sesión de generación de perfiles

  1. En Visual Studio, cree una aplicación de consola de C#.

    En la ventana de inicio, elija Crear un nuevo proyecto. Escriba la consola en el cuadro de búsqueda, seleccione C# como lenguaje y, a continuación, elija Aplicación de consola para .NET. Elija Siguiente. Escriba un nombre de proyecto como ConsoleApp_CopilotProfile y seleccione Siguiente. Elija una plataforma de destino (por ejemplo, .NET 10) y elija Crear.

  2. En el Explorador de soluciones, haga clic con el botón derecho en el nodo Dependencias del proyecto, elija Administrar paquetes NuGet, busque EntityFramework y agregue los siguientes paquetes al proyecto:

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

    La aplicación usa una base de datos en memoria para simplificar la configuración del proyecto.

  3. Reemplace el código de Program.cs por el código siguiente:

    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. Seleccione Compilar > solución de compilación para asegurarse de que las compilaciones de la aplicación no tienen errores.

Preguntar a Copilot para obtener información de generación de perfiles

  1. Abra la ventana Chat de Copilot y use el siguiente símbolo del sistema.

    @Profiler Please evaluate the performance of this code

  2. Seleccione Enviar.

    El @Profiler comando llama al Agente de Copilot Profiler.

    Captura de pantalla de la invocación del agente del generador de perfiles.

    Como alternativa, puede iniciar el agente del generador de perfiles seleccionando manualmente Seleccionar herramientas y habilitando manualmente el Agente de Profiler y, a continuación, cambiando al modo de agente. Con este método, no es necesario usar el @Profiler comando .

    Copilot pregunta si desea ejecutar el generador de perfiles.

    Captura de pantalla de inicio de la solicitud de generación de perfiles.

  3. Elija Confirmar.

    El agente se ejecuta a través de una serie de pasos de forma independiente. Examina el código, agrega compatibilidad con el proyecto de BenchmarkDotNet, incluidas las referencias y los paquetes del proyecto, agrega pruebas comparativas a un nuevo archivo y ejecuta pruebas de comparación con el nuevo código que genera.

    Los resultados de pruebas comparativas se muestran en la ventana Salida, con la salida establecida en Centro de diagnósticos.

    Captura de pantalla de la salida de la prueba comparativa.

    Los resultados de la sesión de diagnóstico aparecen en un informe de archivo .diagsession . Si desea investigar manualmente el uso de cpu, consulte Análisis del rendimiento mediante la generación de perfiles de CPU. Sin embargo, en este escenario, usamos el Agente de Profiler en su lugar.

    Cuando finalice la prueba, el agente resume sus hallazgos.

    El agente informa de un potencial 33% ganancia en la eficacia, principalmente mediante la eliminación de la materialización de tabla completa y una llamada de método innecesaria ToList() .

    Captura de pantalla de los resultados de la prueba.

    El agente también proporciona un par de sugerencias para los pasos siguientes, incluida una opción para optimizar la consulta LINQ.

    Captura de pantalla de sugerencias de código.

    En este ejemplo, se centra en optimizar la consulta LINQ.

  4. Seleccione la segunda sugerencia de Copilot y seleccione Enviar para indicar al agente que optimice la cadena de consultas LINQ.

    El agente actualiza Program.cs y proporciona sugerencias adicionales para optimizar el código. Omitiremos esas sugerencias por ahora.

  5. Eche un vistazo a los cambios de código en Program.cs.

    Captura de pantalla de los cambios de código.

  6. En la parte inferior derecha del editor de código, examine los cambios de código y seleccione Mantener para mantenerlos.

    La consulta optimizada se muestra aquí.

     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. Si desea que el agente realice optimizaciones adicionales, seleccione las sugerencias proporcionadas por el agente o realice preguntas adicionales.

Continuar el chat después de alcanzar el límite de tokens

El Agente de Profiler proporciona resumen inteligente junto con la continuación del subproceso de chat, diseñado para mantener el trabajo fluyendo sin bloquearse al alcanzar los límites del token.

Si un chat con Copilot se aproxima a su cupo de tokens, se le ofrecerá la opción de resumir y continuar en un nuevo hilo.

Resumen del hilo: captura de pantalla.

Si selecciona esta opción, el agente genera automáticamente un resumen conciso y enriquecido del contexto del subproceso de chat actual y lo lleva a una conversación nueva. Esto le permite evitar rehacer cualquier paso.

  • Last updated on